Tutorial: Implantar do GitHub para o Serviço Kubernetes do Azure usando Jenkins

Este tutorial implanta um aplicativo de exemplo do GitHub em um cluster do Serviço Kubernetes do Azure (AKS) configurando a integração contínua (CI) e a implantação contínua (CD) no Jenkins.

Neste tutorial, você concluirá estas tarefas:

Pré-requisitos

Para concluir este tutorial, você precisa destes itens:

• Compreensão básica de Kubernetes, Git, CI/CD e imagens de contêiner

• Um cluster AKS e kubectl configurado com as credenciais do cluster AKS.

• Um registo do Azure Container Registry (ACR), o nome do servidor de início de sessão ACR e o cluster AKS configurado para autenticação com o registo ACR.

• Um controlador Jenkins implantado em uma máquina virtual do Azure.

• A CLI do Azure versão 2.0.46 ou posterior instalada e configurada. Executar az --version para localizar a versão. Se precisar de instalar ou atualizar, veja Install Azure CLI (Instalar o Azure CLI).

• Docker instalado no seu sistema de desenvolvimento

• Uma conta do GitHub, um token de acesso pessoal do GitHub e um cliente Git instalados no seu sistema de desenvolvimento

• Se você fornecer sua própria instância do Jenkins em vez dessa maneira com script de exemplo para implantar o Jenkins, sua instância do Jenkins precisará do Docker instalado e configurado e kubectl.

Preparar seu aplicativo

Neste artigo, você usa um aplicativo de votação do Azure de exemplo que contém uma interface Web e o Redis para armazenamento temporário de dados.

Antes de integrar o Jenkins e o AKS para implantações automatizadas, primeiro prepare e implante manualmente o aplicativo de votação do Azure em seu cluster AKS. Esta implantação manual permite que você veja o aplicativo em ação.

Fork o seguinte repositório GitHub para o aplicativo de exemplo - https://github.com/Azure-Samples/azure-voting-app-redis. Para bifurcar o repositório para a sua própria conta do GitHub, selecione o botão Fork no canto superior direito.

Clone a bifurcação para o seu sistema de desenvolvimento. Certifique-se de usar o URL da sua bifurcação ao clonar este repositório:

git clone https://github.com/<your-github-account>/azure-voting-app-redis.git

Mude para o diretório da bifurcação clonada:

cd azure-voting-app-redis

Para criar as imagens de contêiner necessárias para o aplicativo de exemplo, use o arquivo docker-compose.yaml com docker-compose:

docker-compose up -d

As imagens de base necessárias são extraídas e os contêineres de aplicativos são construídos. Em seguida, você pode usar o comando docker images para ver a imagem criada. Foram transferidas ou criadas três imagens. A imagem azure-vote-front contém a aplicação e utilizar a imagem nginx-flask como base. A redis imagem é usada para iniciar uma instância do Redis:

$ docker images

REPOSITORY                   TAG        IMAGE ID            CREATED             SIZE
azure-vote-front             latest     9cc914e25834        40 seconds ago      694MB
redis                        latest     a1b99da73d05        7 days ago          106MB
tiangolo/uwsgi-nginx-flask   flask      788ca94b2313        9 months ago        694MB

Entre no seu registro de contêiner do Azure.

az acr login -n <acrLoginServer>

Substitua <acrLoginServer> pelo seu servidor de login ACR.

Use o comando docker tag para marcar a imagem com o nome do servidor de login ACR e um número de versão do v1. Use seu próprio <acrLoginServer> nome obtido na etapa anterior:

docker tag azure-vote-front <acrLoginServer>/azure-vote-front:v1

Finalmente, envie a imagem azure-vote-front para o seu registro ACR. Novamente, substitua <acrLoginServer> pelo nome do servidor de login do seu próprio registro ACR, como myacrregistry.azurecr.io:

docker push <acrLoginServer>/azure-vote-front:v1

Implantar o aplicativo de exemplo no AKS

Para implantar o aplicativo de exemplo em seu cluster AKS, você pode usar o arquivo de manifesto do Kubernetes na raiz do repositório de votos do Azure. Abra o arquivo de manifesto azure-vote-all-in-one-redis.yaml com um editor como vi. Substitua microsoft pelo nome do servidor de início de sessão do ACR. Esse valor é encontrado na linha 60 do arquivo de manifesto:

containers:
- name: azure-vote-front
  image: azuredocs/azure-vote-front

Em seguida, use o comando kubectl apply para implantar o aplicativo no cluster AKS:

kubectl apply -f azure-vote-all-in-one-redis.yaml

Um serviço de balanceador de carga do Kubernetes é criado para expor o aplicativo à Internet. Este processo pode demorar alguns minutos. Para monitorar o progresso da implantação do balanceador de carga, use o comando kubectl get service com o --watch argumento.

$ kubectl get service azure-vote-front --watch

Quando o endereço EXTERNAL-IP mudar de pendente para Endereço IP, utilize Control + C para parar o processo de observação do kubectl.

NAME               TYPE           CLUSTER-IP    EXTERNAL-IP   PORT(S)        AGE

Para ver o aplicativo em ação, abra um navegador da Web para o endereço IP externo do seu serviço. O aplicativo de votação do Azure é exibido, conforme mostrado no exemplo a seguir:

Configurar o controlador Jenkins

Aplique as seguintes alterações para habilitar implantações do AKS a partir do Jenkins Controller:

Abra a porta 80 de entrada.

az vm open-port \
--resource-group <Resource_Group_name> \
--name <Jenkins_Controller_VM>  \
--port 80 --priority 1020

Substitua <Resource_Group_name> e <Jenkins_Controller_VM> com os valores apropriados.

SSH no controlador Jenkins

ssh azureuser@<PublicIPAddres>

Substitua <PublicIPAddress> pelo endereço IP do controlador Jenkins.

Instalar & Log no AzCLI

curl -L https://aka.ms/InstallAzureCli | bash

az login

Instalar o Docker

sudo apt-get install apt-transport-https ca-certificates curl software-properties-common -y;
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -;
sudo apt-key fingerprint 0EBFCD88;
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable";
sudo apt-get update;
sudo apt-get install docker-ce -y;

Instale o Kubectl e conecte-se ao AKS

sudo az aks install-cli
sudo az aks get-credentials --resource-group <Resource_Group> --name <AKS_Name>

Substitua <Resource_Group> e <AKS_Name> com os valores apropriados.

Configurar o acesso

sudo usermod -aG docker jenkins;
sudo usermod -aG docker azureuser;
sudo touch /var/lib/jenkins/jenkins.install.InstallUtil.lastExecVersion;
sudo service jenkins restart;
sudo cp ~/.kube/config /var/lib/jenkins/.kube/
sudo chmod 777 /var/lib/jenkins/
sudo chmod 777 /var/lib/jenkins/config

Criar uma variável de ambiente Jenkins

Uma variável de ambiente Jenkins é usada para manter o nome do servidor de login ACR. Esta variável é referenciada durante o trabalho de construção de Jenkins. Para criar essa variável de ambiente, conclua as seguintes etapas:

• No lado esquerdo do portal Jenkins, selecione Manage Jenkins>Configure System

• Em Propriedades Globais, selecione Variáveis de ambiente. Adicione uma variável com o nome ACR_LOGINSERVER e o valor do seu servidor de login ACR.

  

• Quando terminar, selecione Salvar na parte inferior da página.

Criar uma credencial Jenkins para ACR

Durante o processo de CI/CD, Jenkins cria novas imagens de contêiner com base em atualizações de aplicativos e precisa enviar essas imagens por push para o registro ACR.

Para permitir que o Jenkins envie imagens de contêiner atualizadas para o ACR, você precisa especificar credenciais para o ACR.

Para separação de funções e permissões, configure uma entidade de serviço para Jenkins com permissões de Colaborador para seu registro ACR.

Criar uma entidade de serviço para Jenkins usar o ACR

Primeiro, crie uma entidade de serviço usando o comando az ad sp create-for-rbac :

az ad sp create-for-rbac

Este comando produz uma saída semelhante ao exemplo a seguir:

{
  "appId": "<app-ID>",
  "displayName": "azure-cli-2018-09-28-22-19-34",
  "name": "http://azure-cli-2018-09-28-22-19-34",
  "password": "<password>",
  "tenant": "<tenant-ID>"
}

Anote o appId e a palavra-passe. Esses valores são usados nas etapas a seguir para configurar o recurso de credencial no Jenkins.

Obtenha o ID do recurso do seu registro ACR usando o comando az acr show e armazene-o como uma variável.

ACR_ID=$(az acr show --resource-group <Resource_Group> --name <acrLoginServer> --query "id" --output tsv)

Substitua <Resource_Group> e <acrLoginServer> com os valores apropriados.

Crie uma atribuição de função para atribuir os direitos de Colaborador da entidade de serviço ao registro ACR.

az role assignment create --assignee <appID> --role Contributor --scope $ACR_ID

Substitua <appId> pelo valor fornecido na saída do comando pervious use para criar a entidade de serviço.

Criar um recurso de credencial no Jenkins para a entidade de serviço ACR

Com a atribuição de função criada no Azure, agora armazene suas credenciais ACR em um objeto de credencial Jenkins. Essas credenciais são referenciadas durante o trabalho de construção do Jenkins.

De volta ao lado esquerdo do portal Jenkins, selecione Gerenciar Jenkins>Gerenciar credenciais>Jenkins Store>Credenciais globais (sem restrições)>Adicionar credenciais

Verifique se o tipo de credencial é Nome de usuário com senha e insira os seguintes itens:

• Nome de usuário - O appId da entidade de serviço criada para autenticação com seu registro ACR.
• Palavra-passe - A palavra-passe da entidade de serviço criada para autenticação com o registo ACR.
• ID - Identificador de credencial, como acr-credentials

Quando concluído, o formulário de credenciais se parece com o exemplo a seguir:

Selecione OK e retorne ao portal Jenkins.

Criar um projeto Jenkins

Na página inicial do seu portal Jenkins, selecione Novo item no lado esquerdo:

1. Insira azure-vote como nome do trabalho. Escolha o projeto Freestyle e, em seguida, selecione OK

2. Na seção Geral, selecione o projeto GitHub e insira sua URL de repositório bifurcada, como https://github.com/<your-github-account>/azure-voting-app-redis

3. Na seção Gerenciamento de código-fonte, selecione Git, insira sua .git URL de repositório bifurcada, como https://github.com/<your-github-account>/azure-voting-app-redis.git

4. Na seção Build Triggers, selecione GitHub hook trigger for GITscm polling

5. Em Ambiente de Compilação, selecione Usar textos ou arquivos secretos

6. Em Ligações, selecione Adicionar>nome de usuário e senha (separados)

   • Digite ACR_ID para a variável username e ACR_PASSWORD para a variável password

     

7. Escolha adicionar uma etapa de compilação do tipo Executar shell e use o texto a seguir. Esse script cria uma nova imagem de contêiner e a envia por push para o registro ACR.

   # Build new image and push to ACR.
   WEB_IMAGE_NAME="${ACR_LOGINSERVER}/azure-vote-front:kube${BUILD_NUMBER}"
   docker build -t $WEB_IMAGE_NAME ./azure-vote
   docker login ${ACR_LOGINSERVER} -u ${ACR_ID} -p ${ACR_PASSWORD}
   docker push $WEB_IMAGE_NAME
   

8. Adicione outra etapa de compilação do tipo Executar shell e use o texto a seguir. Este script atualiza a implantação do aplicativo no AKS com a nova imagem de contêiner do ACR.

   # Update kubernetes deployment with new image.
   WEB_IMAGE_NAME="${ACR_LOGINSERVER}/azure-vote-front:kube${BUILD_NUMBER}"
   kubectl set image deployment/azure-vote-front azure-vote-front=$WEB_IMAGE_NAME
   

9. Depois de concluído, clique em Salvar.

Teste a compilação do Jenkins

Antes de automatizar o trabalho com base nas confirmações do GitHub, teste manualmente a compilação do Jenkins.

Essa compilação valida se o trabalho foi configurado corretamente. Ele confirma que o arquivo de autenticação Kubernetes adequado está em vigor e que a autenticação para ACR está funcionando.

No menu esquerdo do projeto, selecione Compilar agora.

A primeira compilação é mais longa, pois as camadas de imagem do Docker são puxadas para baixo para o servidor Jenkins.

As compilações executam as seguintes tarefas:

1. Clones o repositório GitHub
2. Cria uma nova imagem de contêiner
3. Envia a imagem do contêiner para o registro ACR
4. Atualiza a imagem usada pela implantação do AKS

Como nenhuma alteração foi feita no código do aplicativo, a interface do usuário da Web permanece inalterada.

Quando o trabalho de compilação estiver concluído, selecione build #1 em build history. Selecione Saída do console e visualize a saída do processo de compilação. A linha final deve indicar uma compilação bem-sucedida.

Criar um webhook do GitHub

Com uma compilação manual bem-sucedida concluída, agora integre o GitHub na compilação do Jenkins. Use um webhook para executar o trabalho de compilação do Jenkins sempre que o código for confirmado no GitHub.

Para criar o webhook do GitHub, conclua as seguintes etapas:

1. Navegue até o repositório bifurcado do GitHub em um navegador da Web.

2. Selecione Configurações e, em seguida, selecione Webhooks no lado esquerdo.

3. Escolha Adicionar webhook. Para o URL de Carga Útil, digite http://<publicIp:8080>/github-webhook/, onde <publicIp> é o endereço IP do servidor Jenkins. Certifique-se de incluir o trailing /. Deixe os outros padrões para o tipo de conteúdo e para acionar eventos push.

4. Selecione Adicionar webhook.

   

Teste o pipeline completo de CI/CD

Agora você pode testar todo o pipeline de CI/CD. Quando você envia por push uma confirmação de código para o GitHub, as seguintes etapas acontecem:

1. O webhook do GitHub notifica Jenkins.
2. Jenkins inicia o trabalho de compilação e extrai a confirmação de código mais recente do GitHub.
3. Uma compilação do Docker é iniciada usando o código atualizado e a nova imagem de contêiner é marcada com o número de compilação mais recente.
4. Essa nova imagem de contêiner é enviada por push para o Registro de Contêiner do Azure.
5. Seu aplicativo em execução no Serviço Kubernetes do Azure é atualizado com a imagem mais recente do Registro de Contêiner do Azure.

Em sua máquina de desenvolvimento, abra o aplicativo clonado com um editor de código. No diretório /azure-vote/azure-vote, abra o arquivo chamado config_file.cfg. Atualize os valores de voto neste arquivo para algo diferente de cães e gatos, conforme mostrado no exemplo a seguir:

# UI Configurations
TITLE = 'Azure Voting App'
VOTE1VALUE = 'Blue'
VOTE2VALUE = 'Purple'
SHOWHOST = 'false'

Quando atualizado, salve o arquivo, confirme as alterações e envie-as para a bifurcação do repositório GitHub. O webhook do GitHub aciona um novo trabalho de compilação no Jenkins. No painel da Web do Jenkins, monitore o processo de compilação. Leva alguns segundos para extrair o código mais recente, criar e enviar a imagem atualizada e implantar o aplicativo atualizado no AKS.

Quando a compilação estiver concluída, atualize seu navegador da Web do aplicativo de votação do Azure de exemplo. Suas alterações são exibidas, conforme mostrado no exemplo a seguir:

Próximos passos