Compilare, testare e distribuire contenitori nel servizio Azure Kubernetes usando GitHub Actions

Articolo
03/28/2024

GitHub Actions offre la flessibilità necessaria per creare un flusso di lavoro automatizzato del ciclo di vita di sviluppo software. È possibile usare più azioni Kubernetes per eseguire la distribuzione nei contenitori da Registro Azure Container al servizio Azure Kubernetes con GitHub Actions.

Prerequisiti

Un account Azure con una sottoscrizione attiva. Se non si dispone di un account, crearne uno gratuitamente.
Un account GitHub. Se non è disponibile, iscriversi per riceverne uno gratuito.
- Quando si usa GitHub Actions, è necessario configurare l'integrazione tra Azure e il repository GitHub. Per configurare l'integrazione, vedere Usare GitHub Actions per connettersi ad Azure.
Un cluster del servizio Azure Kubernetes esistente con un registro Azure Container collegato. Se non è disponibile, vedere Eseguire l'autenticazione con registro Azure Container dal servizio Azure Kubernetes.

GitHub Actions per il servizio Azure Kubernetes

GitHub Actions consente di automatizzare i flussi di lavoro dello sviluppo di software all'interno di GitHub. Per altre informazioni, vedere GitHub Actions per Azure.

Nella tabella seguente vengono elencate le azioni disponibili per AKS:

Nome	Descrizione	Altri dettagli
`azure/aks-set-context`	Impostare il contesto del cluster del servizio Azure Kubernetes di destinazione per altre azioni da usare o eseguire qualsiasi comando kubectl.	azure/aks-set-context
`azure/k8s-set-context`	Impostare il contesto del cluster Kubernetes di destinazione per altre azioni da usare o eseguire qualsiasi comando kubectl.	azure/k8s-set-context
`azure/k8s-bake`	Eseguire il bake del file manifesto da usare per le distribuzioni tramite Helm, kustomize o kompose.	azure/k8s-bake
`azure/k8s-create-secret`	Creare un segreto generico o un segreto docker-registry nel cluster Kubernetes.	azure/k8s-create-secret
`azure/k8s-deploy`	Distribuire manifesti nei cluster Kubernetes.	azure/k8s-deploy
`azure/k8s-lint`	Convalidare/lint i file manifesto.	azure/k8s-lint
`azure/setup-helm`	Installare una versione specifica del file binario Helm nello strumento di esecuzione.	azure/setup-helm
`azure/setup-kubectl`	Installare una versione specifica di kubectl nel runner.	azure/setup-kubectl
`azure/k8s-artifact-substitute`	Aggiornare il tag o il digest per le immagini del contenitore.	azure/k8s-artifact-substitute
`azure/aks-create-action`	Creare un cluster del servizio Azure Kubernetes usando Terraform.	azure/aks-create-action
`azure/aks-github-runner`	Configurare agenti self-hosted per GitHub Actions.	azure/aks-github-runner
`azure/acr-build`	Compilare contenitori con Registro Azure Container.	azure/acr-build

Usare GitHub Actions con il servizio Azure Kubernetes

Ad esempio, è possibile usare GitHub Actions per distribuire un'applicazione nel cluster del servizio Azure Kubernetes ogni volta che viene eseguito il push di una modifica nel repository GitHub. Questo esempio usa l'applicazione Azure Vote.

Nota

Questo esempio usa un'entità servizio per l'autenticazione con il registro Azure Container e il cluster del servizio Azure Kubernetes. In alternativa, è possibile configurare Open ID Connect (OIDC) e aggiornare l'azione azure/login per usare OIDC. Per altre informazioni, vedere Configurare l'account di accesso di Azure con l'autenticazione OpenID Connect.

Creare una copia tramite fork e aggiornare il repository

Passare al repository Azure Vote e selezionare Fork.
Aggiornare per usare il azure-vote-all-in-one-redis.yamlRegistro Azure Containerazure-vote-front per l'immagine. Sostituire <registryName> con il nome del registro.
```
...
      containers:
      - name: azure-vote-front
        image: <registryName>.azurecr.io/azuredocs/azure-vote-front:v1
...
```
Eseguire il commit dell'oggetto aggiornato azure-vote-all-in-one-redis.yaml nel repository.

Creare segreti

Creare un'entità servizio per accedere al gruppo di risorse con il Contributor ruolo usando il comando az ad sp create-for-rbac. Sostituire <SUBSCRIPTION_ID> con l'ID sottoscrizione dell'account Azure e <RESOURCE_GROUP> con il nome del gruppo di risorse contenente il Registro Azure Container.
```
az ad sp create-for-rbac \
    --name "ghActionAzureVote" \
    --scope /subscriptions/<SUBSCRIPTION_ID>/resourceGroups/<RESOURCE_GROUP> \
    --role Contributor \
    --json-auth
```
L'output dovrebbe essere simile all'esempio di output seguente:
```
{
  "clientId": <clientId>,
  "clientSecret": <clientSecret>,
  "subscriptionId": <subscriptionId>,
  "tenantId": <tenantId>,
  ...
}
```
Passare alle impostazioni del repository GitHub e selezionare Segreti di> sicurezza e variabili>Azioni.

Per ogni segreto, selezionare Nuovo segreto repository e immettere il nome e il valore del segreto.

Nome segreto	Valore segreto
AZURE_CREDENTIALS	L'intero output JSON del comando `az ad sp create-for-rbac`.
service_principal	Valore di `<clientId>`.
service_principal_password	Valore di `<clientSecret>`.
sottoscrizione	Valore di `<subscriptionId>`.
tenant	Valore di `<tenantId>`.
registry	Nome del registro.
repository	azuredocs
resource_group	Nome del gruppo di risorse.
cluster_name	Nome del cluster.

Per altre informazioni sulla creazione di segreti, vedere Segreti crittografati.

Creare un file di azioni

Nel repository creare un .github/workflows/main.yml e incollare il contenuto seguente:

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

La sezione on contiene l'evento che attiva l'azione. Nel file di esempio l'azione viene attivata quando viene eseguito il push di una modifica nella directory azure-vote.

La sezione steps contiene ogni azione distinta:

Il codice sorgente checkout usa le azione di checkout GitHub Actions per clonare il repository.
La compilazione di Registro Azure Container usa l'azione di compilazione del Registro Azure Container per compilare l'immagine e caricarla nel registro.
L'account di accesso di Azure usa l'azione di accesso di Azure per accedere all'account Azure.
Impostare il contesto del servizio Azure Kubernetes usa l'azione imposta contesto del servizio Azure Kubernetes per impostare il contesto per il cluster del servizio Azure Kubernetes.
Il programma di installazione di kubectl usa l'azione Kubectl di installazione del servizio Azure Kubectl per installare kubectl nello strumento di esecuzione.
La distribuzione nel servizio Azure Kubernetes usa l'azione di distribuzione di Azure Kubernetes per distribuire l'applicazione nel cluster Kubernetes.

Eseguire il commit del file .github/workflows/main.yml nel repository.
Per verificare che l'azione funzioni, aggiornare azure-vote/azure-vote/config_file.cfg con il contenuto seguente:
```
# UI Configurations
TITLE = 'Azure Voting App'
VOTE1VALUE = 'Fish'
VOTE2VALUE = 'Dogs'
SHOWHOST = 'false'
```
Eseguire il commit dell'oggetto aggiornato azure-vote/azure-vote/config_file.cfg nel repository.
Nel repository selezionare Azioni e verificare che sia in esecuzione un flusso di lavoro. Verificare quindi che il flusso di lavoro abbia un segno di spunta verde e che l'applicazione aggiornata venga distribuita nel cluster.

Passaggi successivi

Esaminare i flussi di lavoro di avvio seguenti per il servizio Azure Kubernetes. Per altre informazioni, vedere Uso dei flussi di lavoro di avvio.

Informazioni su come creare più pipeline in GitHub Actions con il servizio Azure Kubernetes

Informazioni sul servizio Azure Kubernetes