Criar, testar e implantar contêineres no Serviço de Kubernetes do Azure (AKS) usando o GitHub Actions

Artigo
09/22/2023

O GitHub Actions oferece a flexibilidade para criar um fluxo de trabalho do ciclo de vida de desenvolvimento de software automatizado. Você pode usar várias ações do Kubernetes para implantar contêineres do ACR (Registro de Contêiner do Azure) no AKS (Serviço de Kubernetes do Azure) com o GitHub Actions.

Pré-requisitos

Uma conta do Azure com uma assinatura ativa. Se você não tiver, crie uma conta gratuita.
Uma conta do GitHub. Caso ainda não tenha uma, inscreva-se gratuitamente.
- Ao usar o GitHub Actions, você precisa configurar a integração entre o Azure e o repositório GitHub. Para configurar a integração, consulte Usar o GitHub Actions para se conectar ao Azure.
Um cluster do AKS existente com um ACR anexado. Se você não tiver um, consulte Autenticar com o ACR no AKS.

GitHub Actions para AKS

Com o GitHub Actions, é possível automatizar os fluxos de trabalho de desenvolvimento de software de dentro do GitHub. Para obter mais informações, consulte GitHub Actions para Azure.

A tabela a seguir lista as ações disponíveis para o AKS:

Nome	Descrição	Mais detalhes
`azure/aks-set-context`	Define o contexto do cluster do AKS de destino para que outras ações usem ou executem os comandos kubectl.	azure/aks-set-context
`azure/k8s-set-context`	Define o contexto do cluster do Kubernetes de destino para que outras ações usem ou executem os comandos kubectl.	azure/k8s-set-context
`azure/k8s-bake`	Prepara o arquivo de manifesto a ser usado para implantações usando Helm, kustomize ou kompose.	azure/k8s-bake
`azure/k8s-create-secret`	Cria um segredo genérico ou um segredo de registro do Docker no cluster do Kubernetes.	azure/k8s-create-secret
`azure/k8s-deploy`	Implanta manifestos nos clusters do Kubernetes.	azure/k8s-deploy
`azure/k8s-lint`	Valida/limpa os arquivos de manifesto.	azure/k8s-lint
`azure/setup-helm`	Instala uma versão específica do binário Helm no executor.	azure/setup-helm
`azure/setup-kubectl`	Instala uma versão específica do kubectl no executor.	azure/setup-kubectl
`azure/k8s-artifact-substitute`	Atualiza a marca ou o resumo das imagens de contêiner.	azure/k8s-artifact-substitute
`azure/aks-create-action`	Crie um cluster do AKS usando o Terraform.	azure/aks-create-action
`azure/aks-github-runner`	Configura os agentes auto-hospedados para GitHub Actions.	azure/aks-github-runner
`azure/acr-build`	Cria contêineres usando o ACR.	azure/acr-build

Usar o GitHub Actions com o AKS

Por exemplo, você pode usar o GitHub Actions para implantar um aplicativo no cluster do AKS, sempre que uma alteração for enviada para o repositório GitHub. Este exemplo usa o aplicativo Azure Vote.

Observação

Este exemplo usa uma entidade de serviço para autenticação com o ACR e o cluster do AKS. Como alternativa, você pode configurar o Open ID Connect (OIDC) e atualizar a ação azure/login para usar o OIDC. Para obter mais informações, acesse o artigo Configurar logon do Azure com a autenticação OpenID Connect.

Bifurcar e atualizar o repositório

Navegue até o repositório do Azure Vote e selecione Criar fork.
Atualize o azure-vote-all-in-one-redis.yaml para usar o ACR para a imagem azure-vote-front. Substitua o <registryName> pelo nome do seu registro.
```
...
      containers:
      - name: azure-vote-front
        image: <registryName>.azurecr.io/azuredocs/azure-vote-front:v1
...
```
Faça commit do azure-vote-all-in-one-redis.yaml atualizado em seu repositório.

Criar segredos

Crie uma entidade de serviço para acessar o grupo de recursos com a função Contributor usando o comando az ad sp create-for-rbac. Substitua <SUBSCRIPTION_ID> pela ID da assinatura da sua conta do Azure e <RESOURCE_GROUP> pelo nome do grupo de recursos que contém o ACR.
```
az ad sp create-for-rbac \
    --name "ghActionAzureVote" \
    --scope /subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP> \
    --role Contributor \
    --json-auth
```
Seu resultado deve ser semelhante ao seguinte exemplo de saída:
```
{
  "clientId": <clientId>,
  "clientSecret": <clientSecret>,
  "subscriptionId": <subscriptionId>,
  "tenantId": <tenantId>,
  ...
}
```
Navegue até as configurações do repositório GitHub e selecione Segurança>Segredos e variáveis>Ações.

Para cada segredo, selecione Novo Segredo do Repositório e insira o nome e o valor do segredo.

Nome secreto	Valor do segredo
AZURE_CREDENTIALS	A saída JSON inteira no comando `az ad sp create-for-rbac`.
service_principal	O valor de `<clientId>`.
service_principal_password	O valor de `<clientSecret>`.
subscription	O valor de `<subscriptionId>`.
locatário	O valor de `<tenantId>`.
Registro	O nome do registro.
repository	azuredocs
resource_group	O nome do grupo de recursos.
cluster_name	O nome do seu cluster.

Para obter mais informações sobre como criar segredos, confira Segredos criptografados.

Criar arquivo de ações

No repositório, crie um .github/workflows/main.yml e cole no seguinte conteúdo:

name: build_deploy_aks
on:
  push:
    paths:
      - "azure-vote/**"
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout source code 
        uses: actions/checkout@v3
      - name: ACR build
        id: build-push-acr
        uses: azure/acr-build@v1
        with:
          service_principal: ${{ secrets.service_principal }}
          service_principal_password: ${{ secrets.service_principal_password }}
          tenant: ${{ secrets.tenant }}
          registry: ${{ secrets.registry }}
          repository: ${{ secrets.repository }}
          image:  azure-vote-front
          folder: azure-vote
          branch: master
          tag: ${{ github.sha }}
      - name: Azure login
        id: login
        uses: azure/login@v1.4.3
        with:
          creds: ${{ secrets.AZURE_CREDENTIALS }}
      - name: Set AKS context
        id: set-context
        uses: azure/aks-set-context@v3
        with:
          resource-group: '${{ secrets.resource_group }}' 
          cluster-name: '${{ secrets.cluster_name }}'
      - name: Setup kubectl
        id: install-kubectl
        uses: azure/setup-kubectl@v3
      - name: Deploy to AKS
        id: deploy-aks
        uses: Azure/k8s-deploy@v4
        with:
          namespace: 'default'
          manifests: |
             azure-vote-all-in-one-redis.yaml
          images: '${{ secrets.registry }}.azurecr.io/${{ secrets.repository }}/azure-vote-front:${{ github.sha }}'
          pull-images: false

A seção on contém o evento que dispara a ação. No arquivo de exemplo, a ação é disparada quando uma alteração é enviada para o diretório azure-vote.

A seção steps contém cada ação distinta:

O código-fonte do check-out usa a Ação de Check-out do GitHub Actions para clonar o repositório.
O build do ACR usa a Ação de Build do Registro de Contêiner para criar a imagem e carregá-la no registro.
O logon do Azure usa a Ação de Logon do Azure para entrar na conta do Azure.
A definição de contexto do AKS usa a Ação de Definição de Contexto do AKS do Azure para definir o contexto do cluster do AKS.
A instalação do kubectl usa a Ação de Instalação do Kubectl do AKS do Azure para instalar o kubectl no executor.
A Implantação no AKS usa a Ação de Implantação do Kubernetes do Azure para implantar o aplicativo no cluster do Kubernetes.

Confirme o arquivo .github/workflows/main.yml no repositório.
Para confirmar se a ação está funcionando, atualize o azure-vote/azure-vote/config_file.cfg com o seguinte conteúdo:
```
# UI Configurations
TITLE = 'Azure Voting App'
VOTE1VALUE = 'Fish'
VOTE2VALUE = 'Dogs'
SHOWHOST = 'false'
```
Faça commit do azure-vote/azure-vote/config_file.cfg atualizado em seu repositório.
No repositório, selecione Ações e confirme se um fluxo de trabalho está funcionando. Depois, confirme se o fluxo de trabalho tem uma marca de seleção verde e se o aplicativo atualizado foi implantado no cluster.

Próximas etapas

Examine os fluxos de trabalho iniciais a seguir para o AKS. Para obter mais informações, consulte Usar fluxos de trabalho iniciais.

Saiba como criar vários pipelines no GitHub Actions com o AKS

Saiba mais sobre o Serviço de Kubernetes do Azure