Creación de la infraestructura para implementar acciones de GitHub de alta disponibilidad en Azure Kubernetes Service (AKS) mediante Azure Files

En este artículo, creará la infraestructura necesaria para implementar una infraestructura de Controlador de ejecutor de acciones (ARC) de alta disponibilidad en AKS mediante Azure Files y Helm.

Antes de empezar

Revise la introducción a la implementación y asegúrese de cumplir los requisitos previos.
Establezca variables de entorno para su uso en esta guía.
Instale las extensiones necesarias.

Establecimiento de variables de entorno

Establezca las siguientes variables de entorno para usarlas en esta guía:

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

Asegúrese de reemplazar los valores de las siguientes variables necesarias :

AKS_AND_STORAGE_ACCOUNT_RG con el nombre del grupo de recursos usado por la cuenta de almacenamiento y el clúster de AKS.
AKS_CLUSTER_NAME con el nombre del clúster de AKS.
STORAGE_ACCOUNT_NAME con el nombre de la cuenta de almacenamiento.
AKS_STORAGE_ACCOUNT_LOCATION con el nombre de la región en la que se van a crear los recursos. En este ejemplo, los implementamos en la misma región que el clúster de AKS para facilitar el rendimiento y la administración de costos.
GITHUB_CONFIG_URL con la dirección URL de la organización o el repositorio de GitHub.

Si es posible, mantenga las siguientes variables opcionales como valores predeterminados:

NAMESPACE_ARC_CONTROLLER: el nombre del espacio de nombres de Kubernetes para ejecutar el controlador del conjunto de escalado de ejecutores de ARC.
ARC_CONTROLLER_NAME: nombre del controlador del conjunto de escalado de ejecutores de ARC.
NAMESPACE_ARC_RUNNERS: el nombre del espacio de nombres de Kubernetes para ejecutar ejecutores autohospedados de ARC.
ARC_RUNNER_SCALESET_NAME: nombre del conjunto de escalado de ejecutores de ARC.
ARC_RUNNER_GITHUB_SECRET_NAME: nombre del secreto de GitHub.

Instalación de las extensiones necesarias

Las extensiones aks-preview, k8s-extension y amg proporcionan más funcionalidad para administrar clústeres de Kubernetes y consultar recursos de Azure. Instale estas extensiones mediante los siguientes comandos az extension add:

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

Creación de un grupo de recursos

Cree un grupo de recursos con el comando az group create. Este grupo de recursos contendrá el clúster de AKS y la cuenta de almacenamiento de Azure Files.

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

Creación de un clúster de AKS

Cree un clúster de AKS con el 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

Conexión al clúster de AKS

Para administrar un clúster de Kubernetes, use kubectl, el cliente de línea de comandos de Kubernetes. Si usa Azure Cloud Shell, kubectl ya está instalado. Para instalar kubectl localmente, use el comando az aks install-cli.

Configure kubectl para conectarse al clúster de Kubernetes mediante az aks get-credentials command. Con este comando se descargan las credenciales y se configura la CLI de Kubernetes para usarlas.
```
az aks get-credentials --resource-group "${AKS_AND_STORAGE_ACCOUNT_RG}" --name "${AKS_CLUSTER_NAME}"
```
Compruebe la conexión al clúster con el comando kubectl get nodes. Este comando devuelve una lista de nodos en el clúster de AKS.
```
kubectl get nodes
```

Para poder usar un recurso compartido de archivos de Azure Files como volumen de Kubernetes, debe crear una cuenta de almacenamiento de Azure y un recurso compartido de archivos. En esta guía, usamos Azure File Share Premium SMB con compatibilidad con el almacenamiento en caché de metadatos. El mínimo es 100 Gb para cada recurso compartido que cree.

Cree una cuenta de almacenamiento mediante el comando az storage account create. El comando siguiente crea una cuenta de almacenamiento mediante la SKU de 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

Exporte la cadena de conexión como una variable de entorno, que usará para crear el recurso compartido de archivos mediante el comando 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)

Cree el recurso compartido de archivos Premium de 100 Gb mediante el comando az storage share create. En este ejemplo, usamos el almacenamiento en caché de metadatos como nombre del recurso compartido. Si cambia este nombre, también tendrá que cambiar el arc-runners-set-pv.yaml archivo para reflejar este cambio.
```
az storage share create --name metadatacaching --quota 100 --connection-string "${AZURE_STORAGE_CONNECTION_STRING}"
```

Instalación del controlador del conjunto de escalado de ejecutores de ARC

Instale el controlador del conjunto de escalado de ejecutores de ARC mediante el siguiente 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

Creación de secretos de Kubernetes

Azure Files requiere que cree un secreto en AKS con la clave de almacenamiento que se usa para conectar el recurso compartido de archivos de Azure desde el contenedor de pods de AKS.

Exporte la clave de cuenta de almacenamiento como una variable de entorno mediante el az storage account keys list comando .

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

Cree un espacio de nombres de Kubernetes para ejecutar ejecutores autohospedados de ARC mediante el comando kubectl create namespace.
```
kubectl create namespace "${NAMESPACE_ARC_RUNNERS}" 
```

Cree un secreto de Kubernetes para almacenar la clave de almacenamiento del recurso compartido de archivos de Azure mediante el kubectl create secret generic comando .

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

Secreto de aplicación de GitHub

Cree una aplicación de GitHub para permitir que el ejecutor autohospedado acceda a su organización o repositorio de GitHub mediante la guía registro de una aplicación de GitHub . El proceso de creación de GitHub proporciona los parámetros siguientes:
- GITHUB_APP_ID: el identificador de la aplicación de GitHub.
- GITHUB_APP_INSTALLATION_ID: el identificador de instalación de la aplicación de GitHub.
- github_app_private_key: clave privada de la aplicación de GitHub. Debe reemplazar la sección -----BEGIN RSA PRIVATE KEY----- por la clave privada.

Cree un secreto de Kubernetes para almacenar las credenciales de la aplicación de GitHub mediante el kubectl create secret generic comando . Asegúrese de reemplazar los marcadores de posición por los valores reales que obtuvo del proceso de creación de aplicaciones de 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>'

Puede montar un recurso compartido de archivos de Azure Files en varios pods al mismo tiempo mediante AccessMode: ReadWriteMany para montar el mismo recurso compartido de archivos en todos los pods creados por el conjunto de réplicas de Kubernetes de ARC. Usamos el recurso compartido de archivos de Azure Files de las maneras siguientes:

Como una compartición de archivos SMB persistente para almacenar en caché paquetes NuGet utilizados por la aplicación de ejemplo de .NET. El archivo arc-runners-set-pv-pvc.yaml crea el PV y PVC necesarios para montar el recurso compartido de archivos de Azure Files en los pods del conjunto de escalado de ejecutores de ARC. Se recomienda Azure File Premium para esta primera opción. Personalice los parámetros volumeAttributes y de los espacios de nombres en los manifiestos PV y PVC, como se muestra en el ejemplo siguiente:
```
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
```
Como volumen efímero para la carpeta de trabajo de ejecutores de GitHub. También se crean dos clases de almacenamiento: Azure Files Standard (github-azurefile) y Azure File Premium (github-azurefile-premium). Estas clases permiten crear y eliminar volúmenes a petición. Cuando se ejecuta un trabajo de GitHub, se crea un nuevo pod de ejecutor en Kubernetes y se crea y monta un nuevo recurso compartido de archivos de Azure Files. El volumen solo reside durante la ejecución del trabajo. La clase estándar permite cualquier tamaño de volumen y Premium permite un mínimo de 100 Gb de volumen. Puede seleccionar la clase que prefiera. Tenga en cuenta que Premium le ofrece un mejor rendimiento. Puede personalizar el arc-runners-storage-class-files.yaml archivo, pero no es necesario.

Creación del volumen persistente y la notificación de volumen persistente

Cree el volumen persistente y la notificación de volumen persistente mediante el comando kubectl apply.

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

Aplique la clase de almacenamiento para Azure Files mediante el kubectl apply comando .
```
kubectl apply -f ./install/arc-runners-storage-class-files.yaml --wait 
```

Instalación del conjunto de escalado de ejecutores de ARC

El siguiente fragmento de código procede del archivo arc-runners-set-values.yaml de la carpeta de instalación que puede personalizar antes de instalar el gráfico de Helm del ejecutor.

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

En este ejemplo, se usa una versión personalizada de Kubernetes containerMode para incluir montajes de volúmenes de recursos compartidos de archivos de Azure File en paquetes NuGet y en el volumen de carpetas _work efímero.

Los parámetros siguientes no son obligatorios para cambiar:

storageClassName: elija entre "github-azurefile-premium" y "github-azurefile".
storage: elija el tamaño del almacenamiento. 100 Gb como mínimo para Premium.

Los demás parámetros de Helm se establecen en el comando helm install mediante la opción --set.

Por compatibilidad con la característica de contenedor de flujo de trabajo de GitHub que permite ejecutar contenedores dentro de la canalización, montamos un objeto container-podspec-volume con la especificación de pod para el pod de flujo de trabajo creado por ARC al ejecutar flujos de trabajo con la característica de contenedor. Esta especificación de pod se monta desde un mapa de configuración creado en el archivo arc-runners-set-container-pod-spec.yaml del directorio de instalación. No se requieren cambios.

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

Parámetros de gráfico de Helm del conjunto de escalado de ejecutores de ARC

El gráfico de Helm del conjunto de escalado de ejecutores de ARC proporciona algunos parámetros. Los parámetros siguientes son los más importantes al instalar un conjunto de escalado con el montaje del volumen del recurso compartido de Azure File en AKS:

githubConfigUrl: su organización o repositorio de GitHub.
githubConfigSecret: secreto de la aplicación de GitHub para acceder a GitHub desde el ejecutor autohospedado.
minRunners: número mínimo de ejecutores en el conjunto de escalado en espera de nuevos trabajos de GitHub.
maxRunners: número máximo de ejecutores que ejecutan trabajos o esperando nuevos trabajos desde GitHub.
runnerGroup: grupo de ejecutores de GitHub usado por el conjunto de ejecutores de ARC.

Descargue el gráfico de Helm del conjunto de escalado de ejecutores de ARC.

Instalación del gráfico de Helm en AKS

Instale el gráfico de Helm del conjunto de escalado de ejecutores de ARC en AKS mediante el 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

Actualización de una instalación del conjunto de escalado de ejecutor

Si desea actualizar cualquier configuración en el conjunto de escalado de ejecutores de ARC, puede usar el comando helm upgrade --install con los mismos parámetros que usó para instalar el conjunto de escalado. Por ejemplo, si desea cambiar el minRunners parámetro de 1 a 2, puede ejecutar el siguiente comando:

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

Paso siguiente

Implementación y prueba de acciones de GitHub de alta disponibilidad con Azure Files en AKS

Colaboradores

Microsoft mantiene este artículo. Originalmente lo escribieron los siguientes colaboradores:

Jorge Arterio | Promotor sénior de la nube
Jeff Patterson | Administrador de productos principal
Rena Shah | Jefe de producto sénior
Shekhar Singh Sorot | Administrador de productos 2
Erin Schaffer | Desarrollador de contenido 2

Comentarios

¿Le ha resultado útil esta página?

Last updated on 2025-07-28