Criar, testar e implantar contêineres no Serviço Kubernetes do Azure (AKS) usando as Ações do GitHub

Artigo
11/01/2024

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

Pré-requisitos

Uma conta do Azure com uma subscrição ativa. Se você não tiver uma, crie uma conta gratuitamente.
Uma conta GitHub. Se não tiver uma, inscreva-se gratuitamente.
- Ao usar as Ações do GitHub, você precisa configurar a integração entre o Azure e seu repositório do GitHub. Para configurar a integração, consulte Usar ações do GitHub para se conectar ao Azure.
Um cluster AKS existente com um ACR anexado. Se você não tiver um, consulte Autenticar com ACR do AKS.

Ações do GitHub para AKS

Com o GiHub Actions, você pode automatizar seus fluxos de trabalho de desenvolvimento de software a partir do GitHub. Para obter mais informações, consulte Ações do GitHub para Azure.

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

Nome	Descrição	Mais detalhes
`azure/aks-set-context`	Defina o contexto do cluster AKS de destino para outras ações para usar ou executar quaisquer comandos kubectl.	azure/aks-set-context
`azure/k8s-set-context`	Defina o contexto do cluster Kubernetes de destino para outras ações para usar ou executar quaisquer comandos kubectl.	azure/k8s-set-context
`azure/k8s-bake`	Bake arquivo de manifesto para usar em implantações usando Helm, kustomize ou kompose.	Azure/K8S-Bake
`azure/k8s-create-secret`	Crie um segredo genérico ou um segredo de registro do docker no cluster do Kubernetes.	azure/k8s-create-secret
`azure/k8s-deploy`	Implante manifestos em clusters do Kubernetes.	azure/k8s-deploy
`azure/k8s-lint`	Valide/lint seus arquivos de manifesto.	Azure/K8S-lint
`azure/setup-helm`	Instale uma versão específica do binário Helm no corredor.	azure/setup-helm
`azure/setup-kubectl`	Instale uma versão específica do kubectl no corredor.	azure/setup-kubectl
`azure/k8s-artifact-substitute`	Atualize a tag ou resumo para imagens de contêiner.	azure/k8s-artifact-substitute
`azure/aks-create-action`	Crie um cluster AKS usando o Terraform.	azure/aks-create-action
`azure/aks-github-runner`	Configure agentes auto-hospedados para Ações do GitHub.	azure/aks-github-runner
`azure/acr-build`	Crie contêineres usando ACR.	azure/acr-build

Usar ações do GitHub com o AKS

Como exemplo, você pode usar as Ações do GitHub para implantar um aplicativo no cluster AKS sempre que uma alteração for enviada por push para o repositório do GitHub. Este exemplo usa o aplicativo Azure Vote .

Nota

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

Fork e atualizar o repositório

Navegue até o repositório do Azure Vote e selecione Fork.
Atualize o azure-vote-all-in-one-redis.yaml para usar o ACR para a azure-vote-front imagem. Substitua <registryName> pelo nome do seu registo.
```
...
      containers:
      - name: azure-vote-front
        image: <registryName>.azurecr.io/azuredocs/azure-vote-front:v1
...
```
Confirme a atualização azure-vote-all-in-one-redis.yaml no seu repositório.

Criar segredos

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

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

Nome do segredo	Valor secreto
AZURE_CREDENTIALS	A saída JSON inteira do `az ad sp create-for-rbac` comando.
service_principal	O valor de `<clientId>`.
service_principal_password	O valor de `<clientSecret>`.
subscrição	O valor de `<subscriptionId>`.
tenant	O valor de `<tenantId>`.
registo	O nome do seu registo.
repository	AzureDocs
resource_group	O nome do seu grupo de recursos.
cluster_name	O nome do cluster.

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

Criar arquivo de ações

No repositório, crie um .github/workflows/main.yml e cole o 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 on seção contém o evento que dispara a ação. No arquivo de exemplo, a ação é acionada quando uma alteração é enviada por push para o azure-vote diretório.

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

O código-fonte de checkout usa a ação de checkout de ações do GitHub para clonar o repositório.
A compilação do ACR usa a Ação de Compilação do Registro de Contêiner do Azure para criar a imagem e carregá-la em seu registro.
O início de sessão do Azure utiliza a Ação de Início de Sessão do Azure para iniciar sessão na sua conta do Azure.
Definir contexto do AKS usa a Ação Definir Contexto do AKS do Azure para definir o contexto do seu cluster AKS.
O kubectl de instalação usa a Ação Kubectl de Instalação do AKS do Azure para instalar o kubectl em seu corredor.
Implantar no AKS usa a Ação de Implantação do Kubernetes do Azure para implantar o aplicativo em seu cluster Kubernetes.

Confirme o .github/workflows/main.yml arquivo 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'
```
Confirme a atualização azure-vote/azure-vote/config_file.cfg no seu repositório.
No repositório, selecione Ações e confirme se um fluxo de trabalho está em execução. Em seguida, confirme se o fluxo de trabalho tem uma marca de seleção verde e se o aplicativo atualizado é implantado no cluster.

Próximos passos

Analise os seguintes fluxos de trabalho iniciais para o AKS. Para obter mais informações, consulte Usando fluxos de trabalho iniciais.

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

Saiba mais sobre o Serviço Kubernetes do Azure

Partilhar via