Creare l'infrastruttura per la distribuzione ad alta disponibilità di GitHub Actions su Azure Kubernetes Service (AKS) usando Azure Files

In questo articolo, crei l'infrastruttura necessaria per distribuire un'infrastruttura Actions Runner Controller (ARC) ad alta disponibilità su AKS utilizzando Azure Files e Helm.

Prima di iniziare

Impostare le variabili di ambiente

Impostare le variabili di ambiente seguenti da usare in questa guida:

export AKS_AND_STORAGE_ACCOUNT_RG="aks-files-actions"
export AKS_CLUSTER_NAME="aks-actions"
export STORAGE_ACCOUNT_NAME=""
export AKS_STORAGE_ACCOUNT_LOCATION="westus3"
export GITHUB_CONFIG_URL="azure-files-samples/Workloads/azurefiles-actions-aks at master · Azure-Samples/azure-files-samples"

# Optional. Changes might require additional changes on ./install/*.yaml files.

export NAMESPACE_ARC_CONTROLLER="arc-systems"
export ARC_CONTROLLER_NAME="arc-controller"
export NAMESPACE_ARC_RUNNERS="arc-runners"
export ARC_RUNNER_SCALESET_NAME="arc-runner-set"
export ARC_RUNNER_GITHUB_SECRET_NAME=""

Assicurarsi di sostituire i valori per le variabili obbligatorie seguenti:

  • AKS_AND_STORAGE_ACCOUNT_RG con il nome del gruppo di risorse utilizzato dall'account di archiviazione e dal cluster AKS.
  • AKS_CLUSTER_NAME con il nome del cluster del servizio Azure Kubernetes.
  • STORAGE_ACCOUNT_NAME con il nome dell'account di archiviazione.
  • AKS_STORAGE_ACCOUNT_LOCATION con il nome dell'area in cui creare le risorse. In questo esempio, gli elementi vengono distribuiti nella stessa area del cluster AKS per facilitare la gestione delle prestazioni e dei costi.
  • GITHUB_CONFIG_URL con l'URL dell'organizzazione o del repository GitHub.

Se possibile, mantenere le variabili facoltative seguenti come predefinite:

  • NAMESPACE_ARC_CONTROLLER: nome dello spazio dei nomi Kubernetes per eseguire il controller del set di scalabilità degli strumenti di esecuzione ARC.
  • ARC_CONTROLLER_NAME: nome del controller del set di scalabilità degli strumenti di esecuzione ARC.
  • NAMESPACE_ARC_RUNNERS: nome dello spazio dei nomi Kubernetes per l'esecuzione di strumenti di esecuzione self-hosted ARC.
  • ARC_RUNNER_SCALESET_NAME: nome del set di scalabilità di strumenti di esecuzione ARC.
  • ARC_RUNNER_GITHUB_SECRET_NAME: il nome di un segreto di GitHub.

Installare le estensioni necessarie

Le estensioni aks-preview, k8s-extension e amg offrono altre funzionalità per la gestione dei cluster Kubernetes e l'esecuzione di query sulle risorse di Azure. Installare queste estensioni usando i comandi az extension add seguenti:

az extension add --upgrade --name aks-preview --yes --allow-preview true 
az extension add --upgrade --name k8s-extension --yes --allow-preview false 
az extension add --upgrade --name amg --yes --allow-preview false

Creare un gruppo di risorse

Creare un gruppo di risorse usando il comando az group create. Questo gruppo di risorse conterrà il cluster AKS e l'account di archiviazione Azure Files.

az group create \ 
    --name $AKS_AND_STORAGE_ACCOUNT_RG \ 
    --location $AKS_STORAGE_ACCOUNT_LOCATION

Crea un cluster AKS

Creare un cluster AKS usando il comando az aks create.

az aks create --resource-group "${AKS_AND_STORAGE_ACCOUNT_RG}" --name "${AKS_CLUSTER_NAME}" \ 
    --os-sku AzureLinux \ 
    --node-count 1 \ 
    --enable-cluster-autoscaler \ 
    --min-count 1 \ 
    --max-count 3 \ 
    --node-vm-size standard_d4s_v5 \ 
    --max-pods=100 \ 
    --network-plugin azure \ 
    --network-plugin-mode overlay \ 
    --generate-ssh-keys

Connettersi al cluster AKS

Per gestire un cluster Kubernetes, usare il client da riga di comando kubernetes kubectl. kubectl è già installato se si usa Azure Cloud Shell. Per installare kubectl in locale, usare il comando az aks install-cli.

  1. Configurare kubectl per connettersi al cluster Kubernetes usando il az aks get-credentials command. Questo comando scarica le credenziali e configura l'interfaccia della riga di comando di Kubernetes per usarle.

    az aks get-credentials --resource-group "${AKS_AND_STORAGE_ACCOUNT_RG}" --name "${AKS_CLUSTER_NAME}"

  2. Verificare la connessione al cluster usando il comando kubectl get nodes. Questo comando restituisce un elenco di nodi nel cluster AKS.

    kubectl get nodes

Creare una condivisione file di Azure.

Prima di poter usare una condivisione file di File di Azure come volume Kubernetes, è necessario creare un account di archiviazione di Azure e la condivisione file. In questa guida si usa la condivisione file Premium SMB di Azure con supporto per la memorizzazione nella cache dei metadati. Il valore minimo è 100 Gb per ogni condivisione creata.

  1. Creare un account di archiviazione usando il az storage account create comando . Il comando seguente crea un account di archiviazione usando lo SKU Premium_LRS.

    az storage account create --name "${STORAGE_ACCOUNT_NAME}" --resource-group "${AKS_AND_STORAGE_ACCOUNT_RG}" \
    --location "${AKS_STORAGE_ACCOUNT_LOCATION}" \
    --sku Premium_LRS \
    --kind FileStorage

  2. Esportare la stringa di connessione come variabile di ambiente, usata per creare la condivisione file, usando il az storage account show-connection-string comando .

    export AZURE_STORAGE_CONNECTION_STRING=$(az storage account show-connection-string --name "${STORAGE_ACCOUNT_NAME}" --resource-group "${AKS_AND_STORAGE_ACCOUNT_RG}" --query connectionString -o tsv)

  3. Creare la condivisione file Premium da 100 Gb usando il az storage share create comando . In questo esempio viene usato il metadatacaching come nome della condivisione. Se si modifica questo nome, è anche necessario modificare il arc-runners-set-pv.yaml file in modo da riflettere questa modifica.

    az storage share create --name metadatacaching --quota 100 --connection-string "${AZURE_STORAGE_CONNECTION_STRING}"

Installare il controller del set di scalabilità di strumenti di esecuzione ARC

Installare il controller del set di scalabilità di strumenti di esecuzione ARC usando il comando helm install.

helm install "${ARC_CONTROLLER_NAME}" \ 
    --namespace "${NAMESPACE_ARC_CONTROLLER}" \ 
    --create-namespace \
    oci://ghcr.io/actions/actions-runner-controller-charts/gha-runner-scale-set-controller

Creare segreti di Kubernetes

Segreto della chiave di archiviazione della condivisione file di Azure

File di Azure richiede la creazione di un segreto nel servizio Azure Kubernetes con la chiave di archiviazione usata per connettere la condivisione file di Azure dal contenitore pod del servizio Azure Kubernetes.

  1. Esportare la chiave dell'account di archiviazione come variabile di ambiente usando il comando az storage account keys list.

    STORAGE_KEY=$(az storage account keys list --resource-group ${AKS_AND_STORAGE_ACCOUNT_RG} --account-name ${STORAGE_ACCOUNT_NAME} --query "[0].value" -o tsv)

  2. Creare uno spazio dei nomi Kubernetes per eseguire strumenti di esecuzione self-hosted ARC usando il comando kubectl create namespace.

    kubectl create namespace "${NAMESPACE_ARC_RUNNERS}"

  3. Creare un segreto Kubernetes per archiviare la chiave di archiviazione della condivisione file di Azure usando il comando kubectl create secret generic.

    kubectl create secret generic azure-storage-secret \ 
   --namespace "${NAMESPACE_ARC_RUNNERS}" \ 
   --from-literal=azurestorageaccountname=${STORAGE_ACCOUNT_NAME} \ 
   --from-literal=azurestorageaccountkey=${STORAGE_KEY}

Segreto dell'app GitHub

  1. Creare un'app GitHub per consentire allo strumento di esecuzione self-hosted di accedere all'organizzazione o al repository GitHub usando la Guida alla Registrazione di un'app GitHub. Il processo di creazione di GitHub fornisce i parametri seguenti:

    • GITHUB_APP_ID: ID dell'app GitHub.
    • GITHUB_APP_INSTALLATION_ID: ID di installazione dell'app GitHub.
    • github_app_private_key: chiave privata dell'app GitHub. È necessario sostituire la sezione -----BEGIN RSA PRIVATE KEY----- con la chiave privata.

  2. Creare un segreto Kubernetes per archiviare le credenziali dell'app GitHub usando il kubectl create secret generic comando . Assicurarsi di sostituire i segnaposto con i valori effettivi ottenuti dal processo di creazione dell'app GitHub.

    GITHUB_APP_ID="app-id-placeholder"
GITHUB_APP_INSTALLATION_ID="installation-id-placeholder"

kubectl create secret generic ${ARC_RUNNER_GITHUB_SECRET_NAME} \ 
    --namespace=${NAMESPACE_ARC_RUNNERS} \
    --from-literal=github_app_id=${GITHUB_APP_ID} \
    --from-literal=github_app_installation_id=${GITHUB_APP_INSTALLATION_ID} \
    --from-literal=github_app_private_key=' <Private Key read here>'

Configurazioni di condivisione file di Azure

È possibile montare una condivisione file di Azure Files in più pod contemporaneamente usando AccessMode: ReadWriteMany per montare la stessa condivisione file in tutti i pod creati dal set di repliche Kubernetes ARC. La condivisione file di Azure Files viene utilizzata nei modi seguenti:

  • Come condivisione file SMB permanente per memorizzare nella cache i pacchetti NuGet usati dall'applicazione di esempio .NET. Il file arc-runners-set-pv-pvc.yaml crea i PV e PVC richiesti per montare la condivisione file di File di Azure nei pod del set di scalabilità di strumenti di esecuzione ARC. Per questa prima opzione è consigliabile usare File Premium di Azure. Personalizzare volumeAttributes e tutti i parametri degli spazi dei nomi nei manifesti PV e PVC, come illustrato nell'esempio seguente:

    volumeAttributes: 
  resourceGroup: metadata-agroves  # Optional. Only set this when the storage account isn't in the same resource group as node. 
  shareName: metadatacaching
nodeStageSecretRef:
  name: azure-storage-secret
  namespace: arc-runners

  • Come volume temporaneo per la cartella di lavoro dei runner di GitHub. Vengono create anche due classi di archiviazione: File di Azure Standard (github-azurefile) e Azure File Premium (github-azurefile-premium). Queste classi consentono di creare ed eliminare volumi su richiesta. Quando viene eseguito un processo GitHub, viene creato un nuovo runner pod su Kubernetes e viene creata e montata una nuova condivisione di file Azure. Il volume si trova solo durante l'esecuzione del processo. La classe Standard consente qualsiasi dimensione del volume e Premium consente un volume minimo di 100 GB . È possibile selezionare qualsiasi classe preferita. Tenere presente che Premium offre prestazioni migliori. È possibile personalizzare il arc-runners-storage-class-files.yaml file, ma non è obbligatorio.

Creare il volume persistente e la richiesta di volume persistente

  1. Creare il volume persistente e la richiesta di volume persistente usando il comando kubectl apply.

    kubectl apply -f ./install/arc-runners-set-pv-pvc.yaml --namespace "${NAMESPACE_ARC_RUNNERS}" --wait

  2. Applicare la classe di archiviazione per File di Azure usando il kubectl apply comando .

    kubectl apply -f ./install/arc-runners-storage-class-files.yaml --wait

Installare il set di scalabilità di strumenti di esecuzione ARC

Il frammento di codice seguente proviene dal file arc-runners-set-values.yaml nella cartella di installazione che è possibile personalizzare prima di installare il grafico Helm del set di strumenti di esecuzione.

containerMode: 
  type: "kubernetes" # Type can be set to dind or kubernetes 
  ## The following is required when containerMode.type=kubernetes 
  kubernetesModeWorkVolumeClaim: 
    accessModes: ["ReadWriteMany"] 
    storageClassName: "github-azurefile-premium" # or "github-azurefile" for Standard_LRS 
    resources: 
      requests: 
        storage: 100Gi # 100Gi minimum to premium or any size when using Standard_LRS "github-azurefile" storage class 
template: 
  spec: 
  securityContext: 
    fsGroup: 123 # Group used by GitHub default agent image 
  containers: 
  - name: runner 
    image: ghcr.io/actions/actions-runner:latest 
    command: ["/home/runner/run.sh"] 
    env: 
      - name: ACTIONS_RUNNER_REQUIRE_JOB_CONTAINER 
        value: "false" 
      - name: ACTIONS_RUNNER_CONTAINER_HOOK_TEMPLATE 
        value: "/home/runner/container-config/container-podspec.yaml" 
    volumeMounts: 
      - name: "container-podspec-volume" 
        mountPath: "/home/runner/container-config" 
      - name: azurefile 
        mountPath: /home/runner/.nuget/              
  volumes: 
    - name: "container-podspec-volume" 
      configMap: 
        name: hook-extension 
    - name: azurefile 
      persistentVolumeClaim: 
        claimName: azurefile

In questo esempio, viene usata una versione personalizzata di Kubernetes containerMode per includere i montaggi dei volumi di condivisione file di Azure nei pacchetti NuGet e nel volume temporaneo della cartella _work.

I parametri seguenti non sono obbligatori per modificare:

  • storageClassName: scegliere tra "github-azurefile-premium" e "github-azurefile".
  • storage: scegliere le dimensioni dell'archiviazione. Un minimo di 100 GB per Premium.

Gli altri parametri Helm vengono impostati nel helm install comando usando l'opzione --set .

Per garantire la compatibilità con la funzionalità contenitore del flusso di lavoro di GitHub, che consente di eseguire contenitori all'interno della pipeline, montiamo un container-podspec-volume con la specifica del pod per il flusso di lavoro creato da ARC durante l'esecuzione dei workflow con la funzionalità contenitore. Questa specifica di pod viene montata da una mappa di configurazione creata nel file arc-runners-set-container-pod-spec.yaml nella cartella di installazione. Non sono necessarie modifiche.

kubectl apply -f ./install/arc-runners-set-container-pod-spec.yaml

Parametri del grafico Helm del set di scalabilità di strumenti di esecuzione ARC

Il chart Helm di ARC runners scale set fornisce alcuni parametri. I parametri seguenti sono i più importanti quando si installa un set di scalabilità con il montaggio del volume di condivisione File di Azure nel servizio Azure Kubernetes:

  • githubConfigUrl: l'organizzazione o il repository GitHub.
  • githubConfigSecret: segreto dell'app GitHub per accedere a GitHub dallo strumento di esecuzione self-hosted.
  • minRunners: numero minimo di strumenti di esecuzione nel set di scalabilità in attesa di nuovi processi da GitHub.
  • maxRunners: numero massimo di strumenti di esecuzione che eseguono processi o sono in attesa di nuovi processi da GitHub.
  • runnerGroup: gruppo di strumenti di esecuzione di GitHub usato dal set di strumenti di esecuzione ARC.

Scaricare il grafico Helm del set di scalabilità di strumenti di esecuzione ARC.

Installare il grafico Helm nel servizio Azure Kubernetes

Installare il grafico Helm del set di scalabilità di strumenti di esecuzione ARC nel servizio Azure Kubernetes usando il comando helm install.

helm install "${ARC_RUNNER_SCALESET_NAME}" \ 
    --namespace "${NAMESPACE_ARC_RUNNERS}" \ 
    --create-namespace \ 
    --values ./install/arc-runners-set-values.yaml \ 
    --set githubConfigUrl="${GITHUB_CONFIG_URL}" \ 
    --set githubConfigSecret="${ARC_RUNNER_GITHUB_SECRET_NAME}" \ 
    --set minRunners=1 \ 
    --set maxRunners=3 \ 
    --set runnerGroup=default \ 
    oci://ghcr.io/actions/actions-runner-controller-charts/gha-runner-scale-set

Aggiornare un'installazione del set di scalabilità dello strumento di esecuzione

Se si vuole aggiornare qualsiasi configurazione nel set di scalabilità dei runner ARC, è possibile usare il comando helm upgrade --install con gli stessi parametri usati per installare il set di scalabilità. Ad esempio, se si vuole modificare il minRunners parametro da 1 a 2, è possibile eseguire il comando seguente:

helm upgrade --install "${ARC_RUNNER_SCALESET_NAME}" \
    --namespace "${NAMESPACE_ARC_RUNNERS}" \
    --create-namespace \
    --values ./install/arc-runners-set-values.yaml \
    --set githubConfigUrl="${GITHUB_CONFIG_URL}" \
    --set githubConfigSecret="${ARC_RUNNER_GITHUB_SECRET_NAME}" \
    --set minRunners=2 \
    --set maxRunners=3 \
    --set runnerGroup=default \
    oci://ghcr.io/actions/actions-runner-controller-charts/gha-runner-scale-set

Passo successivo

Distribuire e testare GitHub Actions ad alta disponibilità con Azure Files su AKS

Contributori

Microsoft gestisce questo articolo. I collaboratori seguenti l'hanno originariamente scritto:

  • Jorge Arterio | Senior Cloud Advocate
  • Jeff Patterson | Product Manager principale
  • Rena Shah | Senior Product Manager
  • Shekhar Singh Sorot | Product Manager 2
  • Erin Schaffer | Sviluppatore di contenuti 2
  • Last updated on