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

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

Neste tutorial, você concluirá estas tarefas:

Pré-requisitos

Para concluir este tutorial, você precisa desses itens:

• Noções básicas sobre Kubernetes, Git, CI/CD e imagens de contêiner

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

• Um registro do Registro de Contêiner do Azure (ACR), o nome do servidor de logon do ACR e o cluster do AKS configurado para autenticação 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 em seu sistema de desenvolvimento

• Uma conta do GitHub, um token de acesso pessoal do GitHub e um cliente Git instalado em 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.

Preparação do aplicativo

Neste artigo, você usa um aplicativo de votação do Azure de exemplo que contém uma interface da Web e 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 votação do Azure no cluster do AKS. Essa implantação manual permite que você veja o aplicativo em ação.

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

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

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

Vá para o diretório do seu fork clonado:

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 base necessárias são extraídas e os contêineres de aplicativo criados. Em seguida, você pode usar o comando de imagens do Docker para ver a imagem criada. Três imagens foram baixadas ou criadas. A azure-vote-front imagem contém o aplicativo e usa a nginx-flask imagem 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

Faça login no registro de contêiner do Azure.

az acr login -n <acrLoginServer>

Substitua <acrLoginServer> pelo servidor de login do ACR.

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

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

Por fim, faça o push da imagem azure-vote-front para o 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 desplegar o aplicativo de exemplo no cluster do AKS, você pode usar o arquivo de manifesto do Kubernetes na raiz do repositório Azure Vote. Abra o arquivo de azure-vote-all-in-one-redis.yaml manifesto com um editor como vi. Substitua microsoft pelo nome do servidor de logon 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 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 --watch argumento.

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

Depois que o endereço EXTERNAL-IP tiver sido alterado de pendente para um endereço IP, use Control + C para interromper o processo de inspeção 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 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 do Controlador Jenkins:

Abra a porta 80 para 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.

SSH conectar-se ao Controlador Jenkins

ssh azureuser@<PublicIPAddress>

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

Instalar & fazer login na 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 o 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 jenkins

Uma variável de ambiente jenkins é usada para manter 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 seguintes etapas:

• No lado esquerdo do portal do Jenkins,selecione Gerenciar Sistema de Configuração do >

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

  

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

Criar uma credencial jenkins para a ACR

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

Para permitir que o Jenkins envie por push 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 um principal de serviço para 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 um principal 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 os 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 o principal de serviço.

Criar um recurso de credencial no Jenkins para o princípio de serviço do ACR.

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

De volta ao lado esquerdo do portal do Jenkins, selecione Gerenciar Jenkins>Gerenciar Credenciais>Loja do Jenkins>Credenciais globais (irrestritas)>Adicionar Credenciais

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

• Nome de usuário – a appId da entidade de serviço criada para autenticação com o registro do ACR.
• Senha – a senha do principal de serviço criado para autenticação com o registro do ACR.
• ID – Identificador de credencial, como acr-credentials

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

Selecione OK e retorne ao portal do Jenkins.

Criar um projeto jenkins

Na home page do portal do 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 projeto do GitHub e insira o URL do seu repositório forked, como https://github.com/<your-github-account>/azure-voting-app-redis

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

4. Na seção Gatilhos de Compilação, selecione o gatilho do GitHub para pesquisa do GIT SCM.

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

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

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

     

7. Escolha adicionar uma Etapa de Construção do tipo Executar o shell e use o seguinte texto. Esse script cria uma nova imagem de contêiner e a envia por push para o registro do 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 utilize 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 a compilação do Jenkins

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

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

No menu à esquerda do projeto, selecione Compilar Agora.

A primeira compilação é mais longa à medida que as camadas da imagem do Docker são baixadas para o servidor Jenkins.

Os builds fazem as seguintes tarefas:

1. Clona o repositório GitHub
2. Cria uma nova imagem de contêiner
3. Envia a imagem de contêiner para o registro do ACR
4. Atualiza a imagem utilizada 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.

Depois que o trabalho de build for concluído, selecione o build nº 1 no 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 uma compilação manual bem-sucedida concluída, agora integre o GitHub ao build do Jenkins. Use um webhook para executar o trabalho de build 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 seu repositório forkeado no GitHub em um navegador da web.

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

3. Selecione Adicionar webhook. Para a URL de Carga, insira http://<publicIp:8080>/github-webhook/, onde <publicIp> está o endereço IP do servidor Jenkins. Certifique-se de incluir o final /. Deixe os outros padrões configurados para o tipo de conteúdo e para serem acionados em eventos de push.

4. Selecione Adicionar webhook.

   

Testar o pipeline de CI/CD completo

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 ocorrem:

1. O webhook do GitHub notifica Jenkins.
2. O Jenkins inicia o trabalho de build e extrai a confirmação de código mais recente do GitHub.
3. Um build do Docker é iniciado usando o código atualizado e a nova imagem de contêiner é marcada com o número de build mais recente.
4. Essa nova imagem de contêiner é enviada para o Azure Container Registry.
5. Seu 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 chamado config_file.cfg. Atualize os valores de votação neste arquivo para algo diferente de gatos e cães, 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 dê push para o seu fork do repositório GitHub. O webhook do GitHub dispara um novo trabalho de build no Jenkins. No painel web do Jenkins, monitore o processo de compilação. Leva alguns segundos para efetuar pull do código mais recente, criar e enviar por push a imagem atualizada e implantar o aplicativo atualizado no AKS.

Depois que o build for concluído, atualize o 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óximas etapas