Skapa infrastrukturen för att distribuera GitHub Actions med hög tillgänglighet i Azure Kubernetes Service (AKS) med hjälp av Azure Files

I den här artikeln skapar du den infrastruktur som behövs för att distribuera en ARC-infrastruktur (Actions Runner Controller) med hög tillgänglighet på AKS med hjälp av Azure Files och Helm.

Innan du börjar

Ange miljövariabler

Ange följande miljövariabler för användning i den här guiden:

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=""

Ersätt värdena för följande obligatoriska variabler:

  • AKS_AND_STORAGE_ACCOUNT_RG med namnet på den resursgrupp som används av lagringskontot och AKS-klustret.
  • AKS_CLUSTER_NAME med namnet på AKS-klustret.
  • STORAGE_ACCOUNT_NAME med namnet på lagringskontot.
  • AKS_STORAGE_ACCOUNT_LOCATION med namnet på regionen som resurserna ska skapas i. I det här exemplet distribuerar vi dem i samma region som AKS-klustret för att underlätta prestanda- och kostnadshantering.
  • GITHUB_CONFIG_URL med URL:en till GitHub-organisationen eller lagringsplatsen.

Behåll följande valfria variabler som standardvärden om möjligt:

  • NAMESPACE_ARC_CONTROLLER: Namnet på Kubernetes-namnområdet för att köra ARC-runnerns skalningsuppsättningsstyrenhet.
  • ARC_CONTROLLER_NAME: Namnet på ARC-löpares skalningsuppsättningsstyrenhet.
  • NAMESPACE_ARC_RUNNERS: Namnet på Kubernetes-namnrymden för att köra ARC-lokalt installerade löpare.
  • ARC_RUNNER_SCALESET_NAME: Namnet på ARC-löpares skaleringsuppsättning.
  • ARC_RUNNER_GITHUB_SECRET_NAME: Namnet på GitHub-hemligheten.

Installera nödvändiga tillägg

Tilläggen aks-preview, k8s-extension och amg ger fler funktioner för att hantera Kubernetes-kluster och köra frågor mot Azure-resurser. Installera dessa tillägg med hjälp av följande az extension add kommandon:

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

Skapa en resursgrupp

Skapa en resursgrupp med kommandot az group create. Den här resursgruppen kommer att innehålla AKS-klustret och Azure Files-lagringskontot.

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

Skapa ett AKS-kluster

Skapa ett AKS-kluster med hjälp av kommandot 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

Ansluta till AKS-klustret

Om du vill hantera ett Kubernetes-kluster använder du Kubernetes-kommandoradsklienten kubectl. kubectl är redan installerat om du använder Azure Cloud Shell. Om du vill installera kubectl lokalt använder du az aks install-cli kommandot .

  1. Konfigurera kubectl för att ansluta till ditt Kubernetes-kluster med hjälp av az aks get-credentials command. Det här kommandot laddar ned autentiseringsuppgifter och konfigurerar Kubernetes CLI för att använda dem.

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

  2. Kontrollera anslutningen till klustret med hjälp av kubectl get nodes kommandot . Det här kommandot returnerar en lista över noder i ditt AKS-kluster.

    kubectl get nodes

Skapa en Azure-fildelning

Innan du kan använda en Azure Files-fildelning som en Kubernetes-volym måste du skapa ett Azure-lagringskonto och en fildelning. I den här guiden använder vi Azure-filresursen Premium SMB med stöd för cachelagring av metadata. Minimivärdet är 100 Gb för varje resurs som du skapar.

  1. Skapa ett lagringskonto med kommandot az storage account create . Följande kommando skapar ett lagringskonto med hjälp av Premium_LRS SKU.

    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. Exportera anslutningssträngen som en miljövariabel för att skapa fildelningen med hjälp av az storage account show-connection-string kommandot som du använder.

    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. Skapa en Premium-fildelning på 100 Gb med kommandot az storage share create. I det här exemplet använder vi metadatacaching som resursnamn. Om du ändrar det här namnet måste du också ändra filen så att den arc-runners-set-pv.yaml återspeglar den här ändringen.

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

Installera ARC-löparens skalningsuppsättningsstyrenhet

Installera ARC runners scale set controller genom följande helm install kommando.

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

Skapa Kubernetes-hemligheter

Azure filresursdelningens lagringsnyckelhemlighet

Azure Files kräver att du skapar en hemlighet (Secret) på AKS med lagringsnyckeln som används för att ansluta Azure-filresursdelning från AKS-podcontainern.

  1. Exportera lagringskontonyckeln som en miljövariabel med kommandot 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. Skapa ett Kubernetes-namnområde för att köra ARC-lokalt installerade löpare med kommandot kubectl create namespace .

    kubectl create namespace "${NAMESPACE_ARC_RUNNERS}"

  3. Skapa en Kubernetes-hemlighet för att lagra lagringsnyckeln för Azure-fildelning med hjälp av kubectl create secret generic-kommandot.

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

GitHub-apphemlighet

  1. Skapa en GitHub-app så att den självhostade löparen kan komma åt din GitHub-organisation eller arkiv genom att använda guiden Registrera en GitHub-app. Processen för att skapa GitHub ger dig följande parametrar:

    • GITHUB_APP_ID: ID för GitHub-appen.
    • GITHUB_APP_INSTALLATION_ID: Installations-ID för GitHub-appen.
    • github_app_private_key: Den privata nyckeln för GitHub-appen. Du måste ersätta -----BEGIN RSA PRIVATE KEY------sektionen med din privata nyckel.

  2. Skapa en Kubernetes-hemlighet för att lagra autentiseringsuppgifterna för GitHub-appen med kommandot kubectl create secret generic . Se till att du ersätter platshållarna med de faktiska värden som du fick från processen för att skapa GitHub-appen.

    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>'

Azure-fildelningskonfigurationer

Du kan montera en Azure Files-filresurs i flera poddar samtidigt med hjälp av AccessMode: ReadWriteMany för att montera samma filresurs i alla poddar som skapats av ARC Kubernetes-replikuppsättningen. Vi använder Azure Files-filresursen på följande sätt:

  • Som en beständig SMB-filresurs för att cachelagra ett NuGet-paket som används av .NET-exempelprogrammet. Filen arc-runners-set-pv-pvc.yaml skapar den PV och PVC som krävs för att montera Azure Files-filresursen i ARC-löpares skalningsuppsättningspoddar. Vi rekommenderar Azure File Premium för det här första alternativet. volumeAttributes Anpassa och eventuella namnrymdsparametrar på både PV- och PVC-manifest enligt följande exempel:

    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

  • Som en flyktig volym för GitHub runners arbetsmapp. Vi skapar också två lagringsklasser: Azure Files Standard (github-azurefile) och Azure File Premium (github-azurefile-premium). Med de här klasserna kan du skapa och ta bort volymer på begäran. När ett GitHub-jobb körs skapas en ny runner pod på Kubernetes och en ny Azure-filresurs skapas och monteras. Volymen lever bara under jobbkörningen. Standardklassen tillåter alla volymstorlekar och Premium tillåter minst 100 Gb volym. Du kan välja vilken klass du vill. Tänk på att Premium ger dig bättre prestanda. Du kan anpassa arc-runners-storage-class-files.yaml filen, men den krävs inte.

Skapa den beständiga volymen och volymanspråket

  1. Skapa den beständiga volymen och det beständiga volymanspråket med kommandot kubectl apply.

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

  2. Använd lagringsklassen för Azure Files med kommandot kubectl apply .

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

Installera ARC-löpares skalningsuppsättning

Följande kodfragment kommer från arc-runners-set-values.yaml-filen i installationsmappen som du kan anpassa innan du installerar Helm-diagrammet för köraren.

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

I det här exemplet använder vi en anpassad version av Kubernetes containerMode för att inkludera volymmonteringar för Azure fildelningar till NuGet-paket och till den tillfälliga volymen för _work-mappen.

Följande parametrar är inte obligatoriska att ändra:

  • storageClassName: Välj mellan "github-azurefile-premium" och "github-azurefile".
  • storage: Välj lagringens storlek. Minst 100 GB för Premium.

De andra Helm-parametrarna anges för helm install kommandot med hjälp av --set alternativet .

För kompatibilitet med containerfunktionen GitHub Workflow som gör att du kan köra containrar i din pipeline monterar vi en container-podspec-volume med poddspecifikationen för arbetsflödespodden som skapas av ARC när du kör arbetsflöden med containerfunktionen. Den här poddspecifikationen monteras från en konfigurationskarta som skapats på arc-runners-set-container-pod-spec.yaml filen i installationsmappen. Inga ändringar krävs.

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

ARC-löpares skalningsuppsättning Helm-diagramparametrar

Helm-diagrammet för ARC-runners skalningsgrupp innehåller några parametrar. Följande parametrar är de viktigaste när du installerar en skalningsuppsättning med Azure File Share-volymmontering på AKS:

  • githubConfigUrl: Din GitHub-organisation eller lagringsplats.
  • githubConfigSecret: GitHub-apphemligheten för att få åtkomst till GitHub från den lokalt installerade löparen.
  • minRunners: Minsta antalet löpare i skalgruppen som väntar på nya jobb från GitHub.
  • maxRunners: Maximalt antal löpare som kör jobb eller väntar på nya jobb från GitHub.
  • runnerGroup: GitHub-löpargrupp som används av ARC-löpare.

Ladda ned Helm-diagrammet ARC-löpares skalningsuppsättning.

Installera Helm-diagrammet i AKS

Installera ARC-löpares skalningsuppsättning Helm-diagram i AKS med hjälp av helm install kommandot .

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

Uppgradera en installation av ett runner-skalningsset

Om du vill uppgradera någon konfiguration på ARC-löpares skalningsuppsättning kan du använda helm upgrade --install kommandot med samma parametrar som du använde för att installera skalningsuppsättningen. Om du till exempel vill ändra parametern minRunners från 1 till 2 kan du köra följande kommando:

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

Nästa steg

Distribuera och testa GitHub Actions med hög tillgänglighet med Azure Files på AKS

Bidragsgivare

Microsoft ansvarar för den här artikeln. Följande deltagare skrev den ursprungligen:

  • Jorge Arterio | Senior molnrådgivare
  • Jeff Patterson | Principal Product Manager
  • Rena Shah | Senior Product Manager
  • Shekhar Singh Sorot | Product Manager 2
  • Erin Schaffer | Innehållsutvecklare 2
  • Uppdaterades senast