Tworzenie infrastruktury do wdrażania funkcji GitHub Actions o wysokiej dostępności w usłudze Azure Kubernetes Service (AKS) przy użyciu usługi Azure Files

W tym artykule utworzysz infrastrukturę wymaganą do wdrożenia infrastruktury kontrolera GitHub Actions Runner o wysokiej dostępności (ARC) na AKS przy użyciu Azure Files i Helm.

Zanim rozpoczniesz

Zapoznaj się z omówieniem wdrożenia i upewnij się, że spełnisz wymagania wstępne.
Ustaw zmienne środowiskowe do użycia w tym przewodniku.
Zainstaluj wymagane rozszerzenia.

Ustawianie zmiennych środowiskowych

Ustaw następujące zmienne środowiskowe do użycia w tym przewodniku:

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

Pamiętaj, aby zastąpić wartości następujących wymaganych zmiennych:

AKS_AND_STORAGE_ACCOUNT_RG z nazwą grupy zasobów używanej przez konto magazynu i klaster AKS.
AKS_CLUSTER_NAME z nazwą klastra usługi AKS.
STORAGE_ACCOUNT_NAME z nazwą konta magazynowego.
AKS_STORAGE_ACCOUNT_LOCATION z nazwą regionu, w którym mają zostać utworzone zasoby. W tym przykładzie wdrożymy je w tym samym regionie co klaster usługi AKS, aby ułatwić zarządzanie wydajnością i kosztami.
GITHUB_CONFIG_URL przy użyciu adresu URL do organizacji lub repozytorium GitHub.

Jeśli to możliwe, zachowaj następujące opcjonalne zmienne jako domyślne:

NAMESPACE_ARC_CONTROLLER: nazwa namespace Kubernetes dla uruchomienia kontrolera zestawu skalowania runnerów ARC.
ARC_CONTROLLER_NAME: nazwa kontrolera zestawu skalowania biegaczy ARC.
NAMESPACE_ARC_RUNNERS: nazwa przestrzeni nazw Kubernetes dla uruchamiania samodzielnych agentów ARC.
ARC_RUNNER_SCALESET_NAME: nazwa zestawu skalowania ARC runners.
ARC_RUNNER_GITHUB_SECRET_NAME: nazwa sekretu GitHub.

Instalowanie wymaganych rozszerzeń

Rozszerzenia aks-preview, k8s-extension i amg zapewniają więcej funkcji zarządzania klastrami Kubernetes i wykonywania zapytań dotyczących zasobów platformy Azure. Zainstaluj te rozszerzenia przy użyciu następujących az extension add poleceń:

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

Tworzenie grupy zasobów

Utwórz grupę zasobów przy użyciu polecenia az group create. Ta grupa zasobów będzie przechowywać klaster AKS i konto Azure Files.

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

Utwórz klaster AKS

Utwórz klaster AKS przy użyciu polecenia 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

Nawiązywanie połączenia z klastrem usługi AKS

Aby zarządzać klastrem Kubernetes, użyj klienta wiersza polecenia kubernetes kubectl. Narzędzie kubectl jest już zainstalowane, jeśli używasz usługi Azure Cloud Shell. Aby zainstalować narzędzie kubectl lokalnie, użyj az aks install-cli polecenia .

Skonfiguruj narzędzie kubectl, aby nawiązać połączenie z klastrem Kubernetes przy użyciu polecenia az aks get-credentials command. To polecenie pobiera poświadczenia i konfiguruje Kubernetes CLI do ich użycia.
```
az aks get-credentials --resource-group "${AKS_AND_STORAGE_ACCOUNT_RG}" --name "${AKS_CLUSTER_NAME}"
```
Zweryfikuj połączenie z klastrem, używając polecenia kubectl get nodes. To polecenie zwraca listę węzłów w klastrze usługi AKS.
```
kubectl get nodes
```

Aby można było użyć udziału plików usługi Azure Files jako woluminu Kubernetes, należy utworzyć konto usługi Azure Storage i udział plików. W tym przewodniku używamy udziału plików Azure Premium SMB z obsługą buforowania metadanych. Minimalna wartość to 100 Gb dla każdego tworzonego udziału.

Utwórz konto magazynu, używając polecenia az storage account create. Następujące polecenie tworzy konto magazynu przy użyciu wariantu 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

Wyeksportuj ciąg połączenia jako zmienną środowiskową, której używasz do utworzenia udziału plików przy użyciu polecenia az storage account show-connection-string.

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)

Utwórz udział plików Premium o pojemności 100 GB, używając polecenia az storage share create. W tym przykładzie używamy metadatacaching jako nazwy udziału. Jeśli zmienisz tę nazwę, musisz również zmienić plik, arc-runners-set-pv.yaml aby odzwierciedlić tę zmianę.
```
az storage share create --name metadatacaching --quota 100 --connection-string "${AZURE_STORAGE_CONNECTION_STRING}"
```

Instalowanie kontrolera skalowania zestawu uruchamiaczy ARC

Zainstaluj kontroler zestawu skalowania modułów uruchamiaczy ARC przy użyciu następującego helm install polecenia.

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

Tworzenie tajnych danych Kubernetes

Usługa Azure Files wymaga utworzenia wpisu tajnego w usłudze AKS z kluczem magazynu używanym do łączenia udziału plików platformy Azure z kontenera zasobników usługi AKS.

Wyeksportuj klucz konta magazynu jako zmienną środowiskową przy użyciu az storage account keys list polecenia .

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

Utwórz przestrzeń nazw Kubernetes, aby uruchamiać własne agenty ARC przy użyciu polecenia kubectl create namespace.
```
kubectl create namespace "${NAMESPACE_ARC_RUNNERS}" 
```

Utwórz sekret Kubernetes do przechowywania klucza do magazynu udziału plików Azure przy użyciu polecenia 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}

Tajny kod aplikacji GitHub

Utwórz aplikację GitHub, aby umożliwić self-hosted runnerowi dostęp do organizacji lub repozytorium GitHub, korzystając z przewodnika Rejestrowanie aplikacji GitHub. Proces tworzenia usługi GitHub zawiera następujące parametry:
- GITHUB_APP_ID: identyfikator aplikacji GitHub.
- GITHUB_APP_INSTALLATION_ID: identyfikator instalacji aplikacji GitHub.
- github_app_private_key: klucz prywatny aplikacji GitHub. Musisz zastąpić sekcję -----BEGIN RSA PRIVATE KEY----- kluczem prywatnym.

Utwórz tajne hasło Kubernetes do przechowywania poświadczeń aplikacji GitHub za pomocą polecenia kubectl create secret generic. Upewnij się, że symbole zastępcze zostały zastąpione rzeczywistymi wartościami uzyskanymi w procesie tworzenia aplikacji 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>'

Można zamontować udział plików Azure Files w kilku zasobnikach jednocześnie, używając AccessMode: ReadWriteMany do zamontowania tego samego udziału plików we wszystkich zasobnikach utworzonych przez zestaw replik ARC Kubernetes. Udział plików usługi Azure Files jest używany w następujący sposób:

Jako trwały udział plików SMB do buforowania pakietów NuGet używanych przez przykładową aplikację .NET. Plik arc-runners-set-pv-pvc.yaml tworzy wymagany plik PV i PVC, aby zainstalować udział plików usługi Azure Files w zasobnikach zestawu skalowania modułów arc. Zalecamy korzystanie z usługi Azure File Premium dla tej pierwszej opcji. Proszę dostosować volumeAttributes i parametry przestrzeni nazw zarówno w manifestach PV, jak i PVC, jak pokazano w poniższym przykładzie.
```
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
```
Jako efemeryczny wolumin dla folderu roboczego agentów GitHub. Tworzymy również dwie klasy magazynu: Azure Files Standard (github-azurefile) i Azure File Premium (github-azurefile-premium). Te klasy umożliwiają tworzenie i usuwanie woluminów na żądanie. Po uruchomieniu zadania usługi GitHub, nowy zasobnik uruchamiania zostanie utworzony na platformie Kubernetes, a nowa współdzielona przestrzeń plików Azure File zostanie utworzona i zamontowana. Wolumen istnieje tylko podczas przebiegu zadania. Klasa Standardowa umożliwia dowolny rozmiar woluminu, a warstwa Premium zezwala na co najmniej 100 Gb woluminu. Możesz wybrać dowolną preferowaną klasę. Należy pamiętać, że warstwa Premium zapewnia lepszą wydajność. Możesz dostosować arc-runners-storage-class-files.yaml plik, ale nie jest on wymagany.

Utwórz trwały wolumin i trwałe żądanie woluminu

Utwórz trwały wolumin i żądanie trwałego woluminu przy użyciu polecenia kubectl apply.

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

Zastosuj klasę magazynu dla usługi Azure Files za pomocą polecenia kubectl apply.
```
kubectl apply -f ./install/arc-runners-storage-class-files.yaml --wait 
```

Instalowanie zestawu skalowania modułów uruchamiaczy ARC

Poniższy fragment kodu pochodzi z pliku arc-runners-set-values.yaml w folderze instalacyjnym, który można dostosować przed zainstalowaniem pakietu konfiguracyjnego dla Helm chart.

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

W tym przykładzie używamy dostosowanej wersji Kubernetes containerMode do dołączania woluminów udziału plików Azure File do pakietów NuGet oraz do efemerycznego woluminu folderu _work.

Następujące parametry nie są obowiązkowe do zmiany:

storageClassName: wybierz pozycję "github-azurefile-premium" lub "github-azurefile".
storage: wybierz rozmiar pamięci. Minimalne 100 Gb dla wersji Premium.

Inne parametry Helm są ustawiane w poleceniu helm install za pomocą opcji --set.

Aby uzyskać zgodność z funkcją kontenera przepływu pracy usługi GitHub, która umożliwia uruchamianie kontenerów wewnątrz potoku, instalujemy container-podspec-volume zasobnik ze specyfikacją zasobnika przepływu pracy utworzoną przez usługę ARC podczas uruchamiania przepływów pracy z funkcją kontenera. Ta specyfikacja zasobnika jest instalowana na podstawie mapy konfiguracji utworzonej w arc-runners-set-container-pod-spec.yaml pliku w folderze instalacji. Nie są wymagane żadne zmiany.

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

Parametry wykresu Helm dla zestawu skalowania usług ARC

Wykres Helm zestawu skalowania modułów uruchamiaczy ARC zawiera kilka parametrów. Poniżej przedstawiono najważniejsze parametry podczas instalacji zestawu skalowalności z montowaniem woluminu udostępniania plików Azure na platformie AKS.

githubConfigUrl: Twoja organizacja lub repozytorium GitHub.
githubConfigSecret: Wpis tajny aplikacji GitHub umożliwiający dostęp do usługi GitHub z poziomu własnego modułu uruchamiającego.
minRunners: Minimalna liczba programów wykonawczych w zestawie skalowalnym oczekujących na nowe zadania z usługi GitHub.
maxRunners: Maksymalna liczba wykonujących zadania lub oczekujących na nowe zadania runnerów z usługi GitHub.
runnerGroup: grupa runnerów GitHub używana przez zestaw runnerów ARC.

Pobierz Helm chart zestawu skalowania uruchamiaczy ARC.

Zainstaluj pakiet Helm na AKS

Zainstaluj Helm chart zestawu skalowania ARC runners na AKS przy użyciu polecenia 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

Uaktualnianie instalacji zestawu skalowania modułu uruchamiającego

Jeśli chcesz uaktualnić dowolną konfigurację zestawu skalowania agentów ARC, możesz użyć polecenia helm upgrade --install z tymi samymi parametrami, które użyto do zainstalowania zestawu skalowania. Jeśli na przykład chcesz zmienić minRunners parametr z 1 na 2, możesz uruchomić następujące polecenie:

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

Następny krok

Wdrażanie i testowanie funkcji GitHub Actions o wysokiej dostępności za pomocą usługi Azure Files w usłudze AKS

Współautorzy

Firma Microsoft utrzymuje ten artykuł. Następujący autorzy pierwotnie napisali ten tekst:

Jorge Arterio | Starszy ekspert ds. chmury
Jeff Patterson | Główny menedżer produktu
Rena Shah | Starszy menedżer produktu
Shekhar Singh Sorot | Menedżer produktu 2
Erin Schaffer | Content Developer 2

Opinia

Czy ta strona była pomocna?

Ostatnia aktualizacja o 2025-07-22