Tutorial: Implantação do GitHub para o Serviço de Kubernetes do Azure usando o Jenkins

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

Neste tutorial, você concluirá estas tarefas:

Pré-requisitos

Para concluir este tutorial, você precisará destes itens:

• Reconhecimento básico de Kubernetes, Git, CI/CD e imagens de contêiner

• Um cluster do AKS e kubectl configurados com as credenciais de cluster do AKS.

• Um ACR (Registro de Contêiner do Azure), o nome do servidor de logon do ACR e o cluster do AKS configurado para autenticar com o registro do 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. Execute az --version para encontrar a versão. Se você precisa instalar ou atualizar, consulte Instalar a CLI do Azure.

• Docker instalado no sistema de desenvolvimento

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

• Se você fornecer uma instância do Jenkins própria em vez desse modo de script de exemplo para implantar o Jenkins, ela precisará do Docker instalado e configurado e de kubectl.

Preparação do aplicativo

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

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

Faça a bifurcação do repositório do GitHub a seguir para o aplicativo de exemplo – https://github.com/Azure-Samples/azure-voting-app-redis. Para bifurcar o repositório para sua conta do GitHub, selecione o botão Bifurcação no canto superior direito.

Clone a bifurcação no sistema de desenvolvimento. Não se esqueça de usar a URL da sua bifurcação ao clonar este repositório:

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

Altere para o diretório da sua 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

É efetuado o pull das imagens base necessárias e os contêineres do aplicativo são compilados. Em seguida, você pode usar o comando imagens do Docker para ver a imagem criada. Três imagens foram baixadas ou criadas. A imagem azure-vote-front contém o aplicativo e usa a imagem nginx-flask como base. A imagem redis é 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> por seu servidor de logon do ACR.

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

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

Por fim, efetue push da imagem azure-vote-front para seu Registro do ACR. Novamente, substitua <acrLoginServer> pelo nome do servidor de logon do seu próprio Registro do 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 no cluster do AKS, você pode usar o arquivo de manifesto do Kubernetes na raiz do repositório de voto do Azure. Abra o arquivo de manifesto azure-vote-all-in-one-redis.yaml com um editor de texto, como vi. Substitua microsoft pelo nome do servidor de logon do ACR. Esse valor pode ser 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 do 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. Esse processo pode levar alguns minutos. Para monitorar o progresso da implantação do balanceador de carga, use o comando kubectl get service com o argumento --watch.

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

Depois que o endereço EXTERNAL-IP for alterado de pendente para um endereço IP, use Control + C para interromper o processo kubectl watch.

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

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

Configurar o Controlador Jenkins

Aplique as seguintes alterações para habilitar implantações do AKS do Controlador Jenkins:

Abra a porta 80 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> pelos valores apropriados.

Acessar o Controlador Jenkins via SSH

ssh azureuser@<PublicIPAddress>

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

Instalar e fazer logon em 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;

Instalar Kubectl e conectar-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> pelos 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 do Jenkins

Uma variável de ambiente do Jenkins é usada para armazenar o nome do servidor de logon do ACR. Essa variável é referenciada durante o trabalho de build do Jenkins. Para criar essa variável de ambiente, conclua as etapas a seguir:

• No lado esquerdo do portal do Jenkins, selecione Gerenciar o Jenkins>Configurar sistema

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

  

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

Criar uma credencial do Jenkins para ACR

Durante o processo de CI/CD, o Jenkins compila novas imagens de contêiner com base nas atualizações do aplicativo e, em seguida, precisa efetuar push dessas imagens para o Registro do ACR.

Para permitir que o Jenkins efetue push das imagens de contêiner atualizadas para o ACR, é necessário especificar credenciais para o ACR.

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

Criar uma entidade de serviço para o 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

Esse comando produz uma saída semelhante ao seguinte exemplo:

{
  "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 a appId e a senha. Esses valores são usados nas etapas a seguir para configurar o recurso de credencial no Jenkins.

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

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

Substitua <Resource_Group> e <acrLoginServer> pelos valores apropriados.

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

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

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

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

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

No lado esquerdo do portal do Jenkins, selecione Gerenciar Jenkins>Gerenciar Credenciais>Armazenamento do Jenkins>Credenciais globais (irrestrito)>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 o Registro do ACR.
• Senha – a senha da entidade de serviço criada para autenticação com o Registro do ACR.
• ID – identificador de credenciais, como acr-credentials

Ao concluir, o formulário de credenciais será semelhante ao exemplo a seguir:

Selecione OK e retorne ao portal do Jenkins.

Criar um projeto do Jenkins

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

1. Insira azure-vote como nome do trabalho. Escolha Projeto Freestyle e selecione OK

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

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

4. Na seção Gatilhos de Build, selecione Gatilho de gancho do GitHub para sondagem de GITscm

5. Em Ambiente de Build, selecione Usar arquivos ou textos secretos

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

   • Digite ACR_ID para a Variável de Nome de Usuário e ACR_PASSWORD para a Variável de Senha

     

7. Opte por adicionar uma Etapa de Build do tipo Executar shell e use o texto a seguir. Esse script compila uma nova imagem de contêiner e envia-a por push para o registro de 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 Build do tipo Executar shell e use o texto a seguir. Esse 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.

Testar o build do Jenkins

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

Ele valida se o trabalho foi configurado corretamente. Ele confirma que o arquivo de autenticação do Kubernetes correto está no local e que a autenticação no ACR está funcionando.

No menu esquerdo do projeto, selecione Compilar agora.

O primeiro build é mais longo, pois é efetuado pull das camadas de imagem do Docker no servidor do Jenkins.

Os builds realizam as seguintes tarefas:

1. Clonar o repositório do GitHub
2. Compilar uma nova imagem de contêiner
3. Efetuar push da imagem de contêiner para o registro do ACR
4. Atualizar a imagem usada pela implantação do AKS

Como nenhuma alteração foi feita ao código do aplicativo, a interface do usuário da Web não é alterada.

Quando o trabalho de build for concluído, selecione build nº 1 em histórico de build. Selecione Saída do console e exiba a saída do processo de build. A linha final deve indicar um build bem-sucedido.

Criar um webhook do GitHub

Com um build manual de sucesso concluído, agora integre o GitHub no build do Jenkins. Use um webhook para executar o trabalho de build do Jenkins cada vez que o código for confirmado no GitHub.

Para criar o webhook do GitHub, conclua as etapas a seguir:

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

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

3. Escolha Adicionar webhook. Para a URL de payload, digite http://<publicIp:8080>/github-webhook/, em que <publicIp> é o endereço IP do servidor do Jenkins. Não deixe de incluir a / à direita. Deixe os outros padrões para o tipo de conteúdo e para gatilho em eventos de push.

4. Selecione Adicionar webhook.

   

Testar o pipeline de CI/CD completo

Agora, é possível testar o pipeline de CI/CD inteiro. Quando você efetua push de uma confirmação de código para o GitHub, acontecem as etapas a seguir:

1. O webhook do GitHub notifica o Jenkins.
2. O Jenkins inicia o trabalho de build e efetua pull da confirmação de código mais recente do GitHub.
3. Um build do Docker é iniciado usando o código atualizado; a nova imagem de contêiner é marcada com o número de build mais recente.
4. É efetuado push da nova imagem de contêiner para o Registro de Contêiner do Azure.
5. O aplicativo em execução no Serviço de Kubernetes do Azure é atualizado com a imagem mais recente do Registro de Contêiner do Azure.

No computador de desenvolvimento, abra o aplicativo clonado com um editor de código. No diretório /azure-vote/azure-vote, abra o arquivo denominado config_file.cfg. Atualize os valores de voto neste arquivo para algo diferente de gatos e cachorros, como mostrado no exemplo a seguir:

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

Após a atualização, salve o arquivo, confirme as alterações e efetue push para a bifurcação do repositório do GitHub. O webhook do GitHub dispara um novo trabalho de build no Jenkins. No painel da Web do Jenkins, monitore o processo de build. Demora alguns segundos para efetuar pull do código mais recente, criar e efetuar push da imagem atualizada e implantar o aplicativo atualizado no AKS.

Depois que o build estiver concluído, atualize seu navegador da Web do aplicativo de voto do Azure de exemplo. As alterações serão exibidas, como mostra o exemplo a seguir:

Próximas etapas