Como administrador ou desenvolvedor do Code Stream, você pode usar o Code Stream e o VMware Tanzu Kubernetes Grid Integrated Edition (anteriormente conhecido como VMware Enterprise PKS) para automatizar a implantação dos seus aplicativos de software em um cluster Kubernetes. Esse caso de uso menciona outros métodos possíveis para automatizar a liberação do aplicativo.

Neste caso de uso, você criará um pipeline que inclui dois estágios e usará o Jenkins para criar e implantar o aplicativo.

  • O primeiro estágio é para desenvolvimento. Ele usa o Jenkins para extrair o código de uma ramificação no repositório GitHub, depois o compila, testa e publica.
  • O segundo estágio é para implantação. Ele executa uma tarefa de operação do usuário que requer a aprovação de usuários principais antes que o pipeline possa implantar o aplicativo no cluster do Kubernetes.

Ao usar um endpoint API do Kubernetes no espaço de trabalho do pipeline, o Code Stream cria os recursos do Kubernetes necessários, como ConfigMap, Segredo e Pod, para executar a tarefa de integração contínua (CI) ou personalizada. O Code Stream se comunica com o contêiner usando a NodePort.

Para compartilhar os dados em todas as execuções do pipeline, você deve fornecer uma reivindicação de volume persistente, e o Code Stream montará a reivindicação de volume persistente no contêiner para armazenar os dados e a usará nas execuções seguintes do pipeline.

O espaço de trabalho do pipeline do Code Stream é compatível com o Docker e o Kubernetes para tarefas de integração contínua e personalizadas.

Para obter mais informações sobre a configuração do espaço de trabalho, consulte Como configurar o espaço de trabalho do pipeline.

O fluxo de trabalho que implanta um aplicativo em um cluster Kubernetes usa o Jenkins, o Code Stream, o GitHub, o trigger para Git e o Kubernetes.

As ferramentas de desenvolvimento, instâncias de implantação e o arquivo YAML de pipeline devem estar disponíveis para que o pipeline possa compilar, testar, publicar e implantar o aplicativo. O pipeline implantará o aplicativo em instâncias de desenvolvimento e produção de clusters do Kubernetes.

O fluxo de trabalho ajuda você a navegar pelo processo que libera um aplicativo para um cluster Kubernetes.

Outros métodos que automatizam a liberação do aplicativo:

  • Em vez de construir seu aplicativo usando o Jenkins, você pode usar a capacidade de compilação nativa do Code Stream e um host de compilação Docker.
  • Em vez de implantar seu aplicativo em um cluster Kubernetes, você pode implantá-lo em um cluster Amazon Web Services (AWS).

Para obter mais informações sobre como usar o recurso de compilação nativo do Code Stream e um host do Docker, consulte:

Pré-requisitos

  • Verifique se o código do aplicativo a ser implantado reside em um repositório GitHub em funcionamento.
  • Verifique se há uma instância de trabalho Jenkins ativa.
  • Verifique se há um servidor de e-mail ativo.
  • No Code Stream, crie um endpoint de e-mail que se conecte ao servidor de e-mail.
  • Configure dois clusters do Kubernetes no Amazon Web Services (AWS), para desenvolvimento e produção, onde o pipeline implantará o aplicativo.
  • Verifique se o repositório GitHub contém o código YAML para o pipeline e, como alternativa, um arquivo YAML que defina os metadados e as especificações do ambiente.

Procedimento

  1. No Code Stream, clique em Endpoints > Novo Endpoint e crie um endpoint do Jenkins que será usado no pipeline para extrair o código do seu repositório GitHub.
  2. Para criar endpoints do Kubernetes, clique em Novo Endpoint.
    1. Crie um endpoint para seu cluster de desenvolvimento do Kubernetes.
    2. Crie um endpoint para seu cluster de produção do Kubernetes.
      A URL do seu cluster Kubernetes pode ou não incluir um número de porta.
      Por exemplo:
      https://10.111.222.333:6443
      https://api.kubernetesserver.fa2c1d78-9f00-4e30-8268-4ab81862080d.k8s-user.com
  3. Crie um pipeline que implante um contêiner do aplicativo, como o WordPress, no cluster de desenvolvimento do Kubernetes e defina as propriedades de entrada para o pipeline.
    1. Para permitir que o seu pipeline reconheça uma confirmação de código no GitHub que disparará o pipeline, clique na guia Entrada, no próprio pipeline, e selecione Propriedades de Inserção Automática.
    2. Adicione a propriedade chamada GIT_COMMIT_ID e clique na estrela ao lado dela.
      Quando o pipeline for executado, sua execução exibirá a ID de confirmação retornada pelo gatilho Git.
    Em um pipeline que usa o Jenkins e o Kubernetes, a guia Entrada exibe as propriedades de entrada do Git.
  4. Adicione notificações para enviar um e-mail quando o pipeline for bem-sucedido ou falhar.
    1. No pipeline, clique na guia Notificações e clique em Adicionar.
    2. Para adicionar uma notificação por e-mail quando o pipeline terminar de ser executado, selecione E-mail e depois Completa. Em seguida, selecione o servidor de e-mail, digite os endereços de e-mail e clique em Salvar.
    3. Para adicionar outra notificação por e-mail para uma falha de pipeline, selecione Falhar e clique em Salvar.
    Ao adicionar uma notificação por e-mail, você seleciona um dos estados do pipeline e seleciona o servidor de e-mail e os destinatários.
  5. Adicione um estágio de desenvolvimento ao pipeline e tarefas que compilem, testem e publiquem seu aplicativo. Em seguida, valide cada tarefa.
    1. Para compilar seu aplicativo, adicione uma tarefa de Jenkins que use o endpoint do Jenkins e execute um trabalho de compilação a partir do servidor Jenkins. Depois, para que o pipeline receba seu código, insira a ramificação Git desta forma: ${input.GIT_BRANCH_NAME}
    2. Para testar seu aplicativo, adicione uma tarefa de Jenkins que use o mesmo endpoint do Jenkins e execute um trabalho de teste no servidor Jenkins. Em seguida, insira a mesma ramificação Git.
    3. Para publicar seu aplicativo, adicione uma tarefa de Jenkins que use o mesmo endpoint do Jenkins e execute um trabalho de publicação no servidor Jenkins. Em seguida, insira a mesma ramificação Git.
    Em um pipeline que usa o Jenkins e o Kubernetes, a tarefa do Jenkins que cria o aplicativo usa o endpoint Jenkins, o trabalho do Jenkins e o nome da ramificação.
  6. Adicione um estágio de implantação ao seu pipeline e, depois, adicione uma tarefa que exija uma aprovação para a implantação do aplicativo, e outra tarefa que implante o aplicativo no cluster do Kubernetes. Em seguida, valide cada tarefa.
    1. Para exigir uma aprovação na implantação do seu aplicativo, adicione uma tarefa de Operação do Usuário, adicione os endereços de e-mail para os usuários que devem aprová-la e digite uma mensagem. Em seguida, ative Enviar E-mail.
    2. Para implantar o aplicativo, adicione uma tarefa do Kubernetes. Depois, nas propriedades da tarefa do Kubernetes, selecione seu cluster de desenvolvimento do Kubernetes, selecione a ação Criar e selecione a fonte de payload Definição de Local. Em seguida, selecione seu arquivo YAML local.
  7. Adicione um webhook do Git para permitir que o Code Stream use o gatilho Git, que dispara seu pipeline quando os desenvolvedores confirmam o código.
    No webook para Git que aciona o pipeline Kubernetes, você deve inserir a ramificação e um token secreto.
  8. Para testar o pipeline, acesse o repositório GitHub, atualize o arquivo YAML do aplicativo e confirme a alteração.
    1. No Code Stream, verifique se a confirmação é exibida.
    1. Clique em Gatilhos > Git > Atividade.
    2. Procure o gatilho do pipeline.
    3. Clique em Painéis > Painéis de Pipeline.
    4. No painel de pipeline, encontre o GIT_COMMIT_ID na última área de alteração bem-sucedida.
  9. Verifique o código de pipeline e verifique se a alteração é exibida.

Resultados

Parabéns! Você automatizou a implantação do seu aplicativo de software no cluster do Kubernetes.

Exemplo: Exemplo de YAML de pipeline que implanta um aplicativo em um cluster do Kubernetes

Para o tipo de pipeline usado nesse exemplo, o YAML deve ser semelhante ao seguinte código:

apiVersion: v1
kind: Namespace
metadata:
  name: ${input.GIT_BRANCH_NAME}
  namespace: ${input.GIT_BRANCH_NAME}
---  
apiVersion: v1
data:
  .dockercfg: eyJzeW1waG9ueS10YW5nby1iZXRhMi5qZnJvZy5pbyI6eyJ1c2VybmFtZSI6InRhbmdvLWJldGEyIiwicGFzc3dvcmQiOiJhRGstcmVOLW1UQi1IejciLCJlbWFpbCI6InRhbmdvLWJldGEyQHZtd2FyZS5jb20iLCJhdXRoIjoiZEdGdVoyOHRZbVYwWVRJNllVUnJMWEpsVGkxdFZFSXRTSG8zIn19
kind: Secret
metadata:
  name: jfrog
  namespace: ${input.GIT_BRANCH_NAME}
type: kubernetes.io/dockercfg
---   
apiVersion: v1
kind: Service
metadata:
  name: codestream
  namespace: ${input.GIT_BRANCH_NAME}
  labels:
    app: codestream
spec:
  ports:
    - port: 80
  selector:
    app: codestream
    tier: frontend
  type: LoadBalancer 
---
apiVersion: extensions/v1
kind: Deployment
metadata:
  name: codestream
  namespace: ${input.GIT_BRANCH_NAME}
  labels:
    app: codestream
spec:
  selector:
    matchLabels:
      app: codestream
      tier: frontend
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: codestream
        tier: frontend
    spec:
      containers:
      - name: codestream
        image: cas.jfrog.io/codestream:${input.GIT_BRANCH_NAME}-${Dev.PublishApp.output.jobId}
        ports:
        - containerPort: 80
          name: codestream
      imagePullSecrets:
      - name: jfrog
      

O que Fazer Depois

Para implantar o aplicativo de software no cluster de produção do Kubernetes, execute as etapas novamente e selecione o cluster de produção.

Para saber mais sobre a integração do Code Stream com o Jenkins, consulte Como integrar o Code Stream ao Jenkins.