Compartilhar via


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

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

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

  1. Navegue até o repositório do Azure Vote e selecione Criar fork.

  2. 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
    ...
    
  3. Faça commit do azure-vote-all-in-one-redis.yaml atualizado em seu repositório.

Criar segredos

  1. 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>,
      ...
    }
    
  2. Navegue até as configurações do repositório GitHub e selecione Segurança>Segredos e variáveis>Ações.

  3. 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

  1. 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:

    1. O código-fonte do check-out usa a Ação de Check-out do GitHub Actions para clonar o repositório.
    2. O build do ACR usa a Ação de Build do Registro de Contêiner para criar a imagem e carregá-la no registro.
    3. O logon do Azure usa a Ação de Logon do Azure para entrar na conta do Azure.
    4. 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.
    5. A instalação do kubectl usa a Ação de Instalação do Kubectl do AKS do Azure para instalar o kubectl no executor.
    6. A Implantação no AKS usa a Ação de Implantação do Kubernetes do Azure para implantar o aplicativo no cluster do Kubernetes.
  2. Confirme o arquivo .github/workflows/main.yml no repositório.

  3. 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'
    
  4. Faça commit do azure-vote/azure-vote/config_file.cfg atualizado em seu repositório.

  5. 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.