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

Artigo
08/07/2024

Importante

Muitos serviços do Azure têm plug-ins do Jenkins. Alguns desses plug-ins ficarão sem suporte a partir de 29 de fevereiro de 2024. A CLI do Azure é a maneira atualmente recomendada para integrar o Jenkins aos serviços do Azure. Para obter mais informações, confira o artigo Plug-ins do Jenkins para Azure.

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:

Implante um aplicativo de voto do Azure de exemplo para um cluster do AKS.
Crie um projeto básico do Jenkins.
Configure as credenciais para o Jenkins interagir com o ACR.
Crie um trabalho de build do Jenkins e o webhook do GitHub para compilações automatizadas.
Teste o pipeline de CI/CD para atualizar um aplicativo no AKS com base nas confirmações de código do GitHub.

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.

Observação

O aplicativo de voto do Azure de exemplo usa um pod do Linux que está agendado para ser executado em um nó do Linux. O fluxo descrito neste artigo também funciona com um pod do Windows Server agendado em um nó do Windows Server.

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:

Aplicativo de voto de exemplo do Azure em execução no AKS

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@<PublicIPAddres>

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

Instalar e fazer logon em AzCLI

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

az login

Observação

Para instalar AzCLI manualmente, siga estas instruções.

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:

Criar um objeto de credencial do Jenkins com as informações da entidade de serviço

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:

Insira azure-vote como nome do trabalho. Escolha Projeto Freestyle e selecione OK
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
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
Na seção Gatilhos de Build, selecione Gatilho de gancho do GitHub para sondagem de GITscm
Em Ambiente de Build, selecione Usar arquivos ou textos secretos
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

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

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

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.

Build de teste do Jenkins

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

Os builds realizam as seguintes tarefas:

Clonar o repositório do GitHub
Compilar uma nova imagem de contêiner
Efetuar push da imagem de contêiner para o registro do ACR
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:

Navegue até seu repositório bifurcado do GitHub em um navegador da Web.
Selecione Configurações e, em seguida, Webhooks no lado esquerdo.
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.
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:

O webhook do GitHub notifica o Jenkins.
O Jenkins inicia o trabalho de build e efetua pull da confirmação de código mais recente do GitHub.
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.
É efetuado push da nova imagem de contêiner para o Registro de Contêiner do Azure.
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:

Voto do Azure de exemplo no AKS atualizado pelo trabalho de build do Jenkins

Próximas etapas

Jenkins no Azure

Compartilhar via