

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Actions autohospedado se ejecuta en GitHub AWS CodeBuild
<a name="action-runner-overview"></a>

Puedes configurar tu proyecto para configurar ejecutores de GitHub Actions autohospedados en CodeBuild contenedores para procesar tus trabajos de flujo de trabajo de GitHub Actions. Para ello, puedes configurar un webhook con tu CodeBuild proyecto y actualizar el flujo de trabajo de GitHub Actions (YAML) para que utilice ejecutores autohospedados alojados en máquinas. CodeBuild 

Los pasos generales para configurar un CodeBuild proyecto para que ejecute tareas de GitHub Actions son los siguientes:

1. Si aún no lo has hecho, crea un token de acceso personal o conéctate a una OAuth aplicación a la que conectar tu proyecto GitHub.

1. Ve a la CodeBuild consola y crea un CodeBuild proyecto con un webhook y configura tus filtros de webhook.

1. Actualiza el flujo de trabajo de GitHub Actions en YAML GitHub para configurar tu entorno de compilación.

Para obtener un procedimiento más detallado, consulte [Tutorial: Configurar un ejecutor de CodeBuild Actions alojado GitHub](action-runner.md).

Esta función permite que sus trabajos de flujo de trabajo de GitHub Actions se integren de forma nativa AWS, lo que proporciona seguridad y comodidad a través de funciones como IAM AWS CloudTrail, AWS Secrets Manager integración y Amazon VPC. Puede acceder a los tipos de instancias más recientes, incluidas las basadas en ARM.

**Topics**
+ [Acerca del ejecutor de CodeBuild Actions alojado GitHub](action-runner-questions.md)
+ [Tutorial: Configurar un ejecutor de CodeBuild Actions alojado GitHub](action-runner.md)
+ [Solución de problemas del webhook](action-runner-troubleshoot-webhook.md)
+ [El ejecutor Actions hospedado admite anulaciones CodeBuild de GitHub etiquetas](sample-github-action-runners-update-labels.md)
+ [Calcule imágenes compatibles con el CodeBuild ejecutor Actions alojado GitHub](sample-github-action-runners-update-yaml.images.md)

# Acerca del ejecutor de CodeBuild Actions alojado GitHub
<a name="action-runner-questions"></a>

Las siguientes son algunas de las preguntas más frecuentes sobre el ejecutor CodeBuild de GitHub Actions alojado.

## ¿Cuándo debo incluir las anulaciones de instancias e imágenes en la etiqueta?
<a name="action-runner-image-label"></a>

Puedes incluir las modificaciones de imagen e instancia en la etiqueta para especificar un entorno de compilación diferente para cada uno de tus trabajos del flujo de trabajo de GitHub Actions. Esto se puede hacer sin necesidad de crear varios CodeBuild proyectos o webhooks. Por ejemplo, es útil cuando necesita usar una [matriz para sus trabajos de flujo de trabajo](https://docs.github.com/en/actions/using-jobs/using-a-matrix-for-your-jobs).

```
name: Hello World
on: [push]
jobs:
  Hello-World-Job:
    runs-on:
      - codebuild-myProject-${{ github.run_id }}-${{ github.run_attempt }}
        image:${{ matrix.os }}
        instance-size:${{ matrix.size }}
    strategy:
      matrix:
        include:
          - os: arm-3.0
            size: small
          - os: linux-5.0
            size: large
    steps:
      - run: echo "Hello World!"
```

**nota**  
Las comillas pueden ser obligatorias si `runs-on` tiene varias etiquetas que contienen el contexto de GitHub las acciones.

## ¿Puedo CloudFormation utilizarla para esta función?
<a name="action-runner-cfn"></a>

Sí, puedes incluir un grupo de filtros en tu CloudFormation plantilla que especifique un filtro de eventos de trabajo del flujo de trabajo de GitHub Actions en el webhook de tu proyecto.

```
Triggers:
  Webhook: true
  FilterGroups:
    - - Type: EVENT
        Pattern: WORKFLOW_JOB_QUEUED
```

Para obtener más información, consulte [Filtra los eventos de GitHub webhook ()CloudFormation](github-webhook-events-cfn.md).

Si necesitas ayuda para configurar las credenciales del proyecto en tu CloudFormation plantilla, consulta [AWS::CodeBuild::SourceCredential](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codebuild-sourcecredential.html)la *Guía del AWS CloudFormation usuario* para obtener más información.

## ¿Cómo puedo enmascarar los secretos al usar esta característica?
<a name="action-runner-secrets"></a>

De forma predeterminada, los secretos que se imprimen en el registro no están enmascarados. Si desea enmascarar los secretos, puede utilizar la sintaxis siguiente: `::add-mask::value`. A continuación se muestra un ejemplo de cómo puede usar esta sintaxis en el YAML:

```
name: Secret Job
on: [push]
jobs:
  Secret-Job:
    runs-on: codebuild-myProject-${{ github.run_id }}-${{ github.run_attempt }}
    env:
      SECRET_NAME: "secret-name"
    steps:
      - run: echo "::add-mask::$SECRET_NAME"
```

Para obtener más información, consulte [Enmascarar un valor en un inicio de sesión](https://docs.github.com/en/actions/using-workflows/workflow-commands-for-github-actions#masking-a-value-in-a-log) GitHub.

## ¿Puedo recibir eventos de webhook de GitHub Actions desde varios repositorios dentro de un mismo proyecto?
<a name="action-runner-webhooks"></a>

CodeBuild admite webhooks organizativos y globales, que reciben eventos de una organización o empresa específica. Para obtener más información, consulte [GitHub webhooks globales y organizativos](github-global-organization-webhook.md).

## ¿Qué regiones admiten el uso de un CodeBuild ejecutor de GitHub acciones alojado?
<a name="action-runner-hosted-regions"></a>

CodeBuildLos ejecutores de GitHub Actions alojados en él son compatibles en todas las CodeBuild regiones. Para obtener más información sobre Regiones de AWS dónde CodeBuild está disponible, consulta [AWS Servicios por región.](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/)

## ¿Qué plataformas admiten el uso de un CodeBuild ejecutor de GitHub acciones alojado?
<a name="action-runner-platform"></a>

CodeBuild-Los ejecutores de GitHub Actions alojados son compatibles tanto con Amazon EC2 [AWS Lambda](lambda.md)como con Compute. Puede utilizar las siguientes plataformas: Amazon Linux 2, Amazon Linux 2023, Ubuntu y Windows Server Core 2019. Para obtener más información, consulte [Imágenes de computación de EC2](ec2-compute-images.md) y [Imágenes de computación de Lambda](lambda-compute-images.md).

# Tutorial: Configurar un ejecutor de CodeBuild Actions alojado GitHub
<a name="action-runner"></a>

Este tutorial le muestra cómo configurar sus CodeBuild proyectos para ejecutar trabajos de GitHub Actions. Para obtener más información sobre el uso de GitHub Actions con, CodeBuild consulte[Tutorial: Configurar un ejecutor de CodeBuild Actions alojado GitHub](#action-runner).<a name="sample-github-action-runners-prerequisites"></a>

Para completar este tutorial, primero debe:
+ Conéctate con un token de acceso personal, un secreto, una aplicación o GitHub una OAuth aplicación de Secrets Manager. Si quieres conectarte con una OAuth aplicación, debes usar la CodeBuild consola para hacerlo. Si quieres crear un token de acceso personal, puedes usar la CodeBuild consola o la [ImportSourceCredentials API](https://docs.aws.amazon.com/codebuild/latest/APIReference/API_ImportSourceCredentials.html). Para obtener instrucciones adicionales, consulte [GitHub y acceso a GitHub Enterprise Server en CodeBuild](access-tokens-github-overview.md).
+ Conéctate CodeBuild a tu GitHub cuenta. Para ello, puede hacer una de las acciones siguientes:
  + Puedes añadirlo GitHub como proveedor de fuentes en la consola. Puedes conectarte con un token de acceso personal, un secreto de Secrets Manager, una OAuth aplicación o una GitHub aplicación. Para obtener instrucciones, consulte [GitHub y acceso a GitHub Enterprise Server en CodeBuild](access-tokens-github-overview.md).
  + Puedes importar tus GitHub credenciales a través de la [ImportSourceCredentials API](https://docs.aws.amazon.com/cli/latest/reference/codebuild/import-source-credentials.html). Esto solo se puede hacer con un token de acceso personal. Si se conecta mediante una OAuth aplicación, debe conectarse mediante la consola en su lugar. Para obtener instrucciones, consulte [Conéctese GitHub con un token de acceso (CLI)](access-tokens-github.md#access-tokens-github-cli).
**nota**  
Esto solo debe hacerse si no te has conectado GitHub a tu cuenta.

## Paso 1: Crea un CodeBuild proyecto con un webhook
<a name="sample-github-action-runners-create-project"></a>

En este paso, crearás un CodeBuild proyecto con un webhook y lo revisarás en la GitHub consola. También puedes elegir GitHub Enterprise como tu proveedor de código fuente. Para obtener más información sobre cómo crear un webhook en GitHub Enterprise, consulte[GitHub webhooks manuales](github-manual-webhook.md).

**Para crear un CodeBuild proyecto con un webhook**

1. Abre la AWS CodeBuild consola en [https://console.aws.amazon.com/codesuite/codebuild/home](https://console.aws.amazon.com/codesuite/codebuild/home).

1. Cree un proyecto de compilación. Para obtener más información, consulte [Creación de un proyecto de compilación (consola)](create-project.md#create-project-console) y [Ejecutar una compilación (consola)](run-build-console.md).

1. En **Tipo de proyecto**, seleccione **Proyecto de ejecutor**.

   En **Ejecutor**:

   1. Para el **proveedor Runner**, selecciona. **GitHub**

   1. En **Ubicación del ejecutor**, seleccione **Repositorio**.

   1. Para la URL del repositorio en **Repositorio**, elige **https://github.com/user-name/repository-name**.
**nota**  
De forma predeterminada, el proyecto únicamente recibirá eventos `WORKFLOW_JOB_QUEUED` para un solo repositorio. Si quiere recibir eventos para todos los repositorios de una organización o empresa, consulte [GitHub webhooks globales y organizativos](github-global-organization-webhook.md).

1. 
   +  En **Environment (Entorno)**: 
     + Elija una **Imagen del entorno** y una **Computación** compatibles. Ten en cuenta que tienes la opción de anular la configuración de la imagen y la instancia mediante una etiqueta en el flujo de trabajo de Actions (YAML). GitHub Para obtener más información, consulte [Paso 2: actualiza el flujo de trabajo de GitHub Actions (YAML)](#sample-github-action-runners-update-yaml)
   +  En **Buildspec**: 
     + Tenga en cuenta que su especificación de compilación se ignorará a menos que se agregue `buildspec-override:true` como etiqueta. En su lugar, la CodeBuild anulará para usar comandos que configurarán el ejecutor autohospedado.

1. Continúe con los valores predeterminados y, a continuación, elija **Crear el proyecto de compilación**.

1. Abre la GitHub consola en `https://github.com/user-name/repository-name/settings/hooks` para comprobar que se ha creado un webhook y que está habilitado para entregar eventos de **Workflow** Jobs.

## Paso 2: actualiza el flujo de trabajo de GitHub Actions (YAML)
<a name="sample-github-action-runners-update-yaml"></a>

En este paso, actualizarás el archivo YAML del flujo de trabajo de GitHub Actions [https://github.com/](https://github.com/)para configurar tu entorno de compilación y utilizar los ejecutores autohospedados de GitHub Actions. CodeBuild Para obtener más información, consulte [Uso de etiquetas con ejecutores autohospedados](https://docs.github.com/en/actions/hosting-your-own-runners/managing-self-hosted-runners/using-labels-with-self-hosted-runners) y [El ejecutor Actions hospedado admite anulaciones CodeBuild de GitHub etiquetas](sample-github-action-runners-update-labels.md).

### Actualiza tu flujo de trabajo de GitHub Acciones (YAML)
<a name="sample-github-action-runners-update-yaml.setup"></a>

Ve a la [https://docs.github.com/en/actions/hosting-your-own-runners/managing-self-hosted-runners/using-labels-with-self-hosted-runners](https://docs.github.com/en/actions/hosting-your-own-runners/managing-self-hosted-runners/using-labels-with-self-hosted-runners)configuración de tu flujo de trabajo de GitHub Actions (YAML) [https://github.com/](https://github.com/)y actualízala para configurar tu entorno de compilación. Para ello, puede hacer una de las acciones siguientes:
+ Puede especificar el nombre del proyecto y el ID de ejecución, en cuyo caso la compilación usará la configuración de proyecto existente para la computación, la imagen, la versión de la imagen y el tamaño de la instancia. El nombre del proyecto es necesario para vincular los ajustes AWS relacionados con tu trabajo de GitHub Actions a un CodeBuild proyecto específico. Al incluir el nombre del proyecto en el YAML, CodeBuild se pueden invocar trabajos con la configuración de proyecto correcta. Al proporcionar el ID de ejecución, CodeBuild asignará tu compilación a ejecuciones de flujo de trabajo específicas y detendrá la compilación cuando se cancele la ejecución del flujo de trabajo. Para obtener más información, consulte el [contexto de `github`](https://docs.github.com/en/actions/learn-github-actions/contexts#github-context).

  ```
  runs-on: codebuild-<project-name>-${{ github.run_id }}-${{ github.run_attempt }}
  ```
**nota**  
Asegúrate de que *<project-name>* coincide con el nombre del proyecto que creaste en el paso anterior. Si no coincide, no CodeBuild procesará el webhook y es posible que el flujo de trabajo de GitHub Actions se bloquee.

  El siguiente es un ejemplo de un flujo de trabajo YAML de GitHub Actions:

  ```
  name: Hello World
  on: [push]
  jobs:
    Hello-World-Job:
      runs-on:
        - codebuild-myProject-${{ github.run_id }}-${{ github.run_attempt }}
      steps:
        - run: echo "Hello World!"
  ```
+ También puede anular el tipo de computación e imagen en la etiqueta. Consulte [Calcule imágenes compatibles con el CodeBuild ejecutor Actions alojado GitHub](sample-github-action-runners-update-yaml.images.md) para ver una lista de imágenes seleccionadas. Para usar imágenes personalizadas, consulte [El ejecutor Actions hospedado admite anulaciones CodeBuild de GitHub etiquetas](sample-github-action-runners-update-labels.md). El tipo de computación y la imagen de la etiqueta anularán la configuración del entorno en el proyecto. Para anular la configuración de su entorno para una compilación de procesamiento CodeBuild EC2 o Lambda, utilice la siguiente sintaxis:

  ```
  runs-on:
    - codebuild-<project-name>-${{ github.run_id }}-${{ github.run_attempt }}
      image:<environment-type>-<image-identifier>
      instance-size:<instance-size>
  ```

  El siguiente es un ejemplo de un flujo de trabajo YAML de GitHub Actions:

  ```
  name: Hello World
  on: [push]
  jobs:
    Hello-World-Job:
      runs-on:
        - codebuild-myProject-${{ github.run_id }}-${{ github.run_attempt }}
          image:arm-3.0
          instance-size:small
      steps:
        - run: echo "Hello World!"
  ```
+ Puede anular la flota utilizada para su compilación en la etiqueta. Al hacerlo, se anularán los valores de flota configurados en el proyecto para usar la flota especificada. Para obtener más información, consulte [Ejecución de compilaciones en flotas de capacidad reservada](fleets.md). Si quiere anular la configuración de la flota para una compilación de computación de Amazon EC2, utilice la siguiente sintaxis:

  ```
  runs-on:
    - codebuild-<project-name>-${{ github.run_id }}-${{ github.run_attempt }}
      fleet:<fleet-name>
  ```

  Para anular tanto la flota como la imagen utilizadas para la compilación, utilice la sintaxis siguiente:

  ```
  runs-on:
    - codebuild-<project-name>-${{ github.run_id }}-${{ github.run_attempt }}
      fleet:<fleet-name>
      image:<environment-type>-<image-identifier>
  ```

  El siguiente es un ejemplo de un flujo de trabajo YAML de GitHub Actions:

  ```
  name: Hello World
  on: [push]
  jobs:
    Hello-World-Job:
      runs-on:
        - codebuild-myProject-${{ github.run_id }}-${{ github.run_attempt }}
          fleet:myFleet
          image:arm-3.0
      steps:
        - run: echo "Hello World!"
  ```
+ Para ejecutar tus trabajos de GitHub Actions en una imagen personalizada, puedes configurar una imagen personalizada en tu CodeBuild proyecto y evitar tener que incluir una etiqueta de reemplazo de imagen. CodeBuild utilizará la imagen configurada en el proyecto si no se proporciona una etiqueta de anulación de imagen.
+ Si lo desea, puede proporcionar etiquetas distintas de las CodeBuild compatibles. Estas etiquetas se ignorarán para el fin de anular los atributos de la compilación, pero no provocarán un error de la solicitud de webhook. Por ejemplo, agregar `testLabel` como etiqueta no impedirá que la compilación se ejecute.

**nota**  
Si una dependencia proporcionada por los GitHub ejecutores alojados no está disponible en el CodeBuild entorno, puede instalarla mediante GitHub Actions en la ejecución del flujo de trabajo. Por ejemplo, puede usar la acción [https://github.com/actions/setup-python](https://github.com/actions/setup-python) para instalar Python en su entorno de compilación.

### Ejecución de comandos buildspec durante las fases INSTALL, PRE\$1BUILD y POST\$1BUILD
<a name="sample-github-action-runners-update-yaml.buildspec"></a>

De forma predeterminada, CodeBuild omite cualquier comando de buildspec al ejecutar una compilación de Actions autohospedada. GitHub Para ejecutar comandos buildspec durante la compilación, se puede agregar `buildspec-override:true` como sufijo a la etiqueta:

```
runs-on:
  - codebuild-<project-name>-${{ github.run_id }}-${{ github.run_attempt }}
    buildspec-override:true
```

Al usar este comando, CodeBuild se creará una carpeta llamada carpeta de origen `actions-runner` principal del contenedor. Cuando el ejecutor de GitHub Actions se inicie durante la `BUILD` fase, se ejecutará en el `actions-runner` directorio.

Existen varias limitaciones a la hora de utilizar una modificación de las especificaciones de compilación en una compilación de Actions autohospedada: GitHub 
+ CodeBuild no ejecutará los comandos buildspec durante la fase, ya que el ejecutor autohospedado se ejecuta en la `BUILD` fase. `BUILD`
+ CodeBuild no descargará ninguna fuente primaria o secundaria durante la fase. `DOWNLOAD_SOURCE` Si ha configurado un archivo buildspec, solo se descargará ese archivo del origen principal del proyecto.
+ Si un comando de compilación falla en la `INSTALL` fase `PRE_BUILD` o, no CodeBuild se iniciará el ejecutor autohospedado y será necesario cancelar manualmente el trabajo del flujo de trabajo de GitHub Actions.
+ CodeBuild obtiene el token del ejecutor durante la `DOWNLOAD_SOURCE` fase, que tiene un plazo de caducidad de una hora. Si tus `PRE_BUILD` `INSTALL` fases superan una hora, el token de corredor puede caducar antes de que comience el corredor GitHub autohospedado.

## Paso 3: revisión de los resultados
<a name="sample-github-action-runners-verify"></a>

Siempre que se ejecute un flujo de trabajo de GitHub Actions, CodeBuild recibirá los eventos del trabajo del flujo de trabajo a través del webhook. Para cada trabajo del flujo de trabajo, CodeBuild inicia una compilación para ejecutar un ejecutor efímero GitHub de Actions. Este es responsable de ejecutar un único trabajo del flujo de trabajo. Una vez que se complete el trabajo, el ejecutor y el proceso de compilación asociado finalizarán de forma inmediata.

Para ver los registros de trabajos de tu flujo de trabajo, navega hasta tu repositorio, selecciona **Acciones**, elige el flujo de trabajo que desees y, a continuación, elige el **trabajo** específico para el que quieres revisar los registros. GitHub

Puedes revisar las etiquetas solicitadas en el registro mientras el trabajo está esperando a que lo recoja un agente autohospedado. CodeBuild

![\[El registro del trabajo se carga.\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/images/hello-world-loading.png)


Una vez que se haya completado el trabajo, podrá ver el registro de este.

![\[El registro del trabajo\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/images/hello-world-log.png)


## GitHub Opciones de configuración del ejecutor de acciones
<a name="sample-github-action-runners-config"></a>

Puede especificar las siguientes variables de entorno en la configuración del proyecto para modificar la configuración de instalación de los ejecutores autoalojados.

`CODEBUILD_CONFIG_GITHUB_ACTIONS_ORG_REGISTRATION_NAME`  
CodeBuild registrará a los corredores autohospedados con el nombre de la organización especificado como valor de esta variable de entorno. Para obtener más información sobre el registro de los corredores a nivel de la organización y los permisos necesarios, consulte [Crear la configuración de un just-in-time corredor para una organización](https://docs.github.com/en/rest/actions/self-hosted-runners?apiVersion=2022-11-28#create-configuration-for-a-just-in-time-runner-for-an-organization).

`CODEBUILD_CONFIG_GITHUB_ACTIONS_ENTERPRISE_REGISTRATION_NAME`  
CodeBuild registrará los corredores autohospedados con el nombre de empresa especificado como valor de esta variable de entorno. Para obtener más información sobre el registro de los ejecutores a nivel empresarial y los permisos necesarios, consulte [Crear la configuración de un just-in-time ejecutor para una empresa](https://docs.github.com/en/enterprise-server/rest/actions/self-hosted-runners?apiVersion=2022-11-28#create-configuration-for-a-just-in-time-runner-for-an-enterprise).  
De forma predeterminada, los ejecutores empresariales no están disponibles en los repositorios de la organización. Para que los ejecutores autoalojados recojan trabajos de flujos de trabajo, es posible que deba configurar los ajustes de acceso al grupo de ejecutores. Para obtener más información, consulte [Making enterprise runners available to repositories](https://docs.github.com/en/enterprise-server/actions/hosting-your-own-runners/managing-self-hosted-runners/adding-self-hosted-runners#making-enterprise-runners-available-to-repositories).

`CODEBUILD_CONFIG_GITHUB_ACTIONS_RUNNER_GROUP_ID`  
CodeBuild registrará los corredores autohospedados con el ID entero del grupo de corredores almacenado como valor de esta variable de entorno. De forma predeterminada este valor es 1. Para obtener más información sobre los grupos de ejecutores autoalojados, consulte [Administración del acceso a los ejecutores autohospedados mediante grupos](https://docs.github.com/en/rest/actions/self-hosted-runners?apiVersion=2022-11-28#create-configuration-for-a-just-in-time-runner-for-an-organization).

`CODEBUILD_CONFIG_GITHUB_ACTIONS_ORG_REGISTRATION_NAME`  
Para configurar el registro de los ejecutores a nivel de organización mediante el archivo YAML del flujo de trabajo de GitHub Actions, puedes usar la siguiente sintaxis:  

```
name: Hello World
on: [push]
jobs:
  Hello-World-Job:
    runs-on:
      - codebuild-myProject-${{ github.run_id }}-${{ github.run_attempt }}
        organization-registration-name:myOrganization
    steps:
      - run: echo "Hello World!"
```

`CODEBUILD_CONFIG_GITHUB_ACTIONS_ENTERPRISE_REGISTRATION_NAME`  
Para configurar el registro de ejecutores de nivel empresarial mediante el archivo YAML del flujo de trabajo de GitHub Actions, puedes usar la siguiente sintaxis:  

```
name: Hello World
on: [push]
jobs:
  Hello-World-Job:
    runs-on:
      - codebuild-myProject-${{ github.run_id }}-${{ github.run_attempt }}
        enterprise-registration-name:myEnterprise
    steps:
      - run: echo "Hello World!"
```

`CODEBUILD_CONFIG_GITHUB_ACTIONS_RUNNER_GROUP_ID`  
Para configurar el registro de los corredores con un ID de grupo de corredores específico mediante el archivo YAML del flujo de trabajo de GitHub Actions, puedes usar la siguiente sintaxis:  

```
name: Hello World
on: [push]
jobs:
  Hello-World-Job:
    runs-on:
      - codebuild-myProject-${{ github.run_id }}-${{ github.run_attempt }}
        registration-group-id:3
    steps:
      - run: echo "Hello World!"
```

## Filtrar los eventos del webhook de GitHub Actions ()CloudFormation
<a name="sample-github-action-runners-webhooks-cfn"></a>

La siguiente parte de una plantilla de CloudFormation con formato YAML crea un grupo de filtros que desencadena una compilación cuando se evalúa como true. El siguiente grupo de filtros especifica una solicitud de trabajo de flujo de trabajo de GitHub Actions con un nombre de flujo de trabajo que coincide con la expresión `\[CI-CodeBuild\]` regular.

```
CodeBuildProject:
  Type: AWS::CodeBuild::Project
  Properties:
    Name: MyProject
    ServiceRole: service-role
    Artifacts:
      Type: NO_ARTIFACTS
    Environment:
      Type: LINUX_CONTAINER
      ComputeType: BUILD_GENERAL1_SMALL
      Image: aws/codebuild/standard:5.0
    Source:
      Type: GITHUB
      Location: CODEBUILD_DEFAULT_WEBHOOK_SOURCE_LOCATION
    Triggers:
      Webhook: true
      ScopeConfiguration:
        Name: organization-name
        Scope: GITHUB_ORGANIZATION
      FilterGroups:
        - - Type: EVENT
            Pattern: WORKFLOW_JOB_QUEUED
          - Type: WORKFLOW_NAME
            Pattern: \[CI-CodeBuild\]
```

## Filtrar GitHub acciones (webhook events)AWS CDK
<a name="sample-github-action-runners-webhooks-cdk"></a>

La siguiente AWS CDK plantilla crea un grupo de filtros que activa una compilación cuando se evalúa como verdadera. El siguiente grupo de filtros especifica una solicitud de trabajo del flujo de trabajo de GitHub Actions.

```
import { aws_codebuild as codebuild } from 'aws-cdk-lib';
import {EventAction, FilterGroup} from "aws-cdk-lib/aws-codebuild";

const source = codebuild.Source.gitHub({
      owner: 'owner',
      repo: 'repo',
      webhook: true,
      webhookFilters: [FilterGroup.inEventOf(EventAction.WORKFLOW_JOB_QUEUED)],
    })
```

## Filtrar GitHub acciones y eventos de webhook (Terraform)
<a name="sample-github-action-runners-webhooks-terraform"></a>

La siguiente plantilla de Terraform crea un grupo de filtros que desencadena una compilación cuando se evalúa como true. El siguiente grupo de filtros especifica una solicitud de trabajo del flujo de trabajo de GitHub Actions.

```
resource "aws_codebuild_webhook" "example" {
  project_name = aws_codebuild_project.example.name
  build_type   = "BUILD"
  filter_group {
    filter {
      type    = "EVENT"
      pattern = "WORKFLOW_JOB_QUEUED"
    }
  }
}
```

## Filtrar GitHub acciones y eventos de webhook ()AWS CLI
<a name="sample-github-action-runners-webhooks-cli"></a>

Los siguientes AWS CLI comandos crean un proyecto de ejecución de GitHub Actions autohospedado con un grupo de filtros de solicitudes de trabajo del flujo de trabajo de GitHub Actions que activa una compilación cuando se evalúa como verdadera.

```
aws codebuild create-project \
--name <project name> \
--source "{\"type\":\"GITHUB\",\"location\":\"<repository location>\",\"buildspec\":\"\"}" \
--artifacts {"\"type\":\"NO_ARTIFACTS\""} \
--environment "{\"type\": \"LINUX_CONTAINER\",\"image\": \"aws/codebuild/amazonlinux-x86_64-standard:5.0\",\"computeType\": \"BUILD_GENERAL1_MEDIUM\"}" \
--service-role "<service role ARN>"
```

```
aws codebuild create-webhook \
--project-name <project name> \
--filter-groups "[[{\"type\":\"EVENT\",\"pattern\":\"WORKFLOW_JOB_QUEUED\"}]]"
```

# Solución de problemas del webhook
<a name="action-runner-troubleshoot-webhook"></a>

**Problema:** el webhook que configuraste [Tutorial: Configurar un ejecutor de CodeBuild Actions alojado GitHub](action-runner.md) no funciona o tu flujo de trabajo no funciona. GitHub

**Causas posibles:**
+ Puede que el evento **Trabajos de flujo de trabajo** del webhook no pueda desencadenar una compilación. Revise los registros de **Respuesta** para ver la respuesta o el mensaje de error.
+ Sus trabajos se asignan a un agente de ejecutor incorrecto debido a su configuración de etiquetas. Este problema puede producirse cuando uno de los trabajos de una sola ejecución de flujo de trabajo tiene menos etiquetas que otro trabajo. Por ejemplo, si tiene dos trabajos con las siguientes etiquetas en la misma ejecución de flujo de trabajo:
  + **Trabajo 1**: `codebuild-myProject-${{ github.run_id }}-${{ github.run_attempt }}`
  + **Trabajo 2**: `codebuild-myProject-${{ github.run_id }}-${{ github.run_attempt }}`, `instance-size:medium`

  Al enrutar un trabajo de GitHub Actions autohospedado, GitHub lo enrutará a cualquier ejecutor con todas las etiquetas especificadas para el trabajo. Este comportamiento significa que el ejecutor creado para **Trabajo 1** o **Trabajo 2** puede recoger **Trabajo 1**, pero **Trabajo 2** solo lo puede recoger el ejecutor creado para **Trabajo 2**, ya que tiene una etiqueta adicional. Si el ejecutor creado para **Trabajo 1** recoge **Trabajo 1**, **Trabajo 2** se bloqueará, ya que el ejecutor de **Trabajo 1** no tiene la etiqueta `instance-size:medium`.

**Soluciones recomendadas:**

Al crear varios trabajos dentro de la misma ejecución de flujo de trabajo, utilice el mismo número de anulaciones de etiquetas para cada trabajo o asigne a cada trabajo una etiqueta personalizada, como `job1` o `job2`.

Si el error persiste, sigue estas instrucciones para solucionar el problema.

1. Abre la GitHub consola en `https://github.com/user-name/repository-name/settings/hooks` para ver la configuración de webhook de tu repositorio. En esta página, verá un webhook que se ha creado para su repositorio.

1. Elija **Edit** y confirme que el webhook está habilitado para entregar eventos **Workﬂow jobs**.  
![\[Los eventos de trabajo del flujo de trabajo están habilitados en su webhook.\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/images/github-actions-workflow-jobs.png)

1.  Vaya a la pestaña **Recent Deliveries**, busque el evento `workflow_job.queued` correspondiente y expándalo. 

1.  Revise el campo de **etiquetas** en **Payload** y asegúrese de que tiene los valores esperados. 

1.  Por último, revisa la pestaña **Respuesta**, ya que contiene la respuesta o el mensaje de CodeBuild error devuelto.   
![\[La respuesta o el mensaje de error devuelto desde CodeBuild.\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/images/github-actions-workflow-jobs-response.png)

1.  Como alternativa, puedes depurar los errores de los webhooks utilizando GitHub. APIs Puede ver las entregas recientes de un webhook mediante la API [List deliveries for a repository webhook](https://docs.github.com/en/rest/repos/webhooks?apiVersion=2022-11-28#list-deliveries-for-a-repository-webhook): 

   ```
   gh api \
     -H "Accept: application/vnd.github+json" \
     -H "X-GitHub-Api-Version: 2022-11-28" \
     /repos/owner/repo/hooks/hook-id/deliveries
   ```

    Después de encontrar la entrega de webhook que deseas depurar y anotar el ID de la entrega, puedes usar la API [Get a delivery for a](https://docs.github.com/en/rest/repos/webhooks?apiVersion=2022-11-28#get-a-delivery-for-a-repository-webhook) repository webhook. CodeBuildPuedes encontrar la respuesta a la carga útil de entrega del webhook en la sección: `response` 

   ```
   gh api \
     -H "Accept: application/vnd.github+json" \
     -H "X-GitHub-Api-Version: 2022-11-28" \
     /repos/owner/repo/hooks/hook-id/deliveries/delivery-id
   ```

**Problema:** Cuando GitHub las reglas de [protección del despliegue están](https://docs.github.com/en/actions/managing-workflow-runs-and-deployments/managing-deployments/reviewing-deployments) habilitadas, las acciones se implementan CodeBuild antes de que se apruebe la implementación.

**Causas posibles:** CodeBuild busca la implementación y el entorno asociados al trabajo de GitHub Actions, si existen, para comprobar si están aprobados. Si CodeBuild no se obtiene la implementación o el entorno, es posible que la CodeBuild compilación se active prematuramente.

**Soluciones recomendadas:** compruebe que las credenciales asociadas a sus CodeBuild proyectos tengan permisos de lectura para las implementaciones y las acciones internas. GitHub

# El ejecutor Actions hospedado admite anulaciones CodeBuild de GitHub etiquetas
<a name="sample-github-action-runners-update-labels"></a>

En tu flujo de trabajo de GitHub Actions (YAML), puedes incluir una variedad de sustituciones de etiquetas que modifiquen la compilación del ejecutor autohospedado. Se CodeBuild ignorarán todas las compilaciones que no reconozcas, pero no rechazarán tu solicitud de webhook. Por ejemplo, el siguiente YAML de flujo de trabajo incluye anulaciones para imagen, tamaño de instancia, flota y buildspec:

```
name: Hello World
on: [push]
jobs:
  Hello-World-Job:
    runs-on:
      - codebuild-myProject-${{ github.run_id }}-${{ github.run_attempt }}
        image:${{ matrix.os }}
        instance-size:${{ matrix.size }}
        fleet:myFleet
        buildspec-override:true
    strategy:
      matrix:
        include:
          - os: arm-3.0
            size: small
          - os: linux-5.0
            size: large
    steps:
      - run: echo "Hello World!"
```

**nota**  
Si su trabajo de flujo de trabajo está pendiente GitHub, consulte [Uso [Solución de problemas del webhook](action-runner-troubleshoot-webhook.md) de etiquetas personalizadas para enrutar trabajos](https://docs.github.com/en/enterprise-server@3.12/actions/hosting-your-own-runners/managing-self-hosted-runners/using-self-hosted-runners-in-a-workflow?learn=hosting_your_own_runners&learnProduct=actions#using-custom-labels-to-route-jobs).

`codebuild-<project-name>-${{github.run_id}}-${{github.run_attempt}}` (obligatorio)
+ Ejemplo: `codebuild-fake-project-${{ github.run_id }}-${{ github.run_attempt }}`
+ Necesario para el flujo de trabajo de todas GitHub las acciones YAMLs. *<project name>*debe ser igual al nombre del proyecto para el que está configurado el webhook del ejecutor autohospedado.

`image:<environment-type>-<image-identifier>`
+ Ejemplo: `image:arm-3.0`
+ Anula la imagen y el tipo de entorno utilizados al iniciar la compilación del ejecutor autoalojado con una imagen seleccionada. Para obtener más información sobre los valores admitidos, consulte [Calcule imágenes compatibles con el CodeBuild ejecutor Actions alojado GitHub](sample-github-action-runners-update-yaml.images.md).
  + Para anular la imagen y el tipo de entorno utilizados con una imagen personalizada, utilice `image:custom-<environment-type>-<custom-image-identifier>`
  + Ejemplo: `image:custom-arm-public.ecr.aws/codebuild/amazonlinux-aarch64-standard:3.0`
**nota**  
Si la imagen personalizada se encuentra en un registro privado, consulte [Configuración de una credencial de registro privada para ejecutores autoalojados](private-registry-sample-configure-runners.md).

`instance-size:<instance-size>`
+ Ejemplo: `instance-size:medium`
+ Anula el tipo de instancia utilizado al iniciar la compilación del ejecutor autoalojado. Para obtener más información sobre los valores admitidos, consulte [Calcule imágenes compatibles con el CodeBuild ejecutor Actions alojado GitHub](sample-github-action-runners-update-yaml.images.md).

`fleet:<fleet-name>`
+ Ejemplo: `fleet:myFleet`
+ Anula la configuración de flota establecida en el proyecto para usar la flota especificada. Para obtener más información, consulte [Ejecución de compilaciones en flotas de capacidad reservada](fleets.md).

`buildspec-override:<boolean>`
+ Ejemplo: `buildspec-override:true`
+ Permite que la compilación ejecute comandos buildspec en las fases `INSTALL`, `PRE_BUILD` y `POST_BUILD` si está establecido en `true`.

## Anulación de una sola etiqueta (heredado)
<a name="sample-github-action-runners-update-single-labels"></a>

CodeBuild permite proporcionar varias anulaciones en una sola etiqueta mediante lo siguiente:
+ Para anular la configuración del entorno en una compilación de computación de Amazon EC2 o Lambda, utilice la sintaxis siguiente:

  ```
  runs-on: codebuild-<project-name>-${{ github.run_id }}-${{ github.run_attempt }}-<environment-type>-<image-identifier>-<instance-size>
  ```
+ Para anular la configuración de la flota en una compilación de computación de Amazon EC2, utilice la sintaxis siguiente:

  ```
  runs-on: codebuild-<project-name>-${{ github.run_id }}-${{ github.run_attempt }}-fleet-<fleet-name>
  ```
+ Para anular tanto la flota como la imagen utilizadas para la compilación, utilice la sintaxis siguiente:

  ```
  runs-on: codebuild-<project-name>-${{ github.run_id }}-${{ github.run_attempt }}-image-<image-version>-fleet-<fleet-name>
  ```
+ Para ejecutar comandos buildspec durante la compilación, se puede agregar `-with-buildspec` como sufijo a la etiqueta:

  ```
  runs-on: codebuild-<project-name>-${{ github.run_id }}-${{ github.run_attempt }}-<image>-<image-version>-<instance-size>-with-buildspec
  ```
+ Si lo desea, puede proporcionar una anulación del tamaño de la instancia sin anular la imagen. En el caso de las compilaciones de Amazon EC2, puede excluir tanto el tipo de entorno como el identificador de imagen. En el caso de las compilaciones de Lambda, puede excluir el identificador de imagen.

# Calcule imágenes compatibles con el CodeBuild ejecutor Actions alojado GitHub
<a name="sample-github-action-runners-update-yaml.images"></a>

En la etiqueta que configuró[Tutorial: Configurar un ejecutor de CodeBuild Actions alojado GitHub](action-runner.md), puede anular la configuración del entorno de Amazon EC2 utilizando los valores de las tres primeras columnas. CodeBuild proporciona las siguientes imágenes informáticas de Amazon EC2. Para obtener más información acerca de 

<a name="build-env-ref.supported-images"></a>[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/sample-github-action-runners-update-yaml.images.html)

Además, puede anular la configuración del entorno de Lambda mediante los siguientes valores. Para obtener más información sobre la computación CodeBuild Lambda, consulte. [Ejecute compilaciones en el AWS Lambda cómputo](lambda.md) CodeBuild admite las siguientes imágenes de procesamiento Lambda:

<a name="lambda.supported-images"></a>[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/codebuild/latest/userguide/sample-github-action-runners-update-yaml.images.html)

Para obtener más información, consulte [Modos y tipos de computación del entorno de compilación](build-env-ref-compute-types.md) y [Imágenes de Docker proporcionadas por CodeBuild](build-env-ref-available.md).