# Creación de una acción de contenedor de Docker

En este tutorial, aprenderás cómo crear una acción de contenedor Docker.

## Introducción

Esta guía te muestra los pasos mínimos necesarios para desarrollar una acción de contenedor de Docker. Para centrar esta guía en los componentes necesarios para empaquetar la acción, la funcionalidad del código de la acción es mínima. La acción imprime "Hola mundo" en los registros o "Hello \[who-to-greet]"si proporcionas un nombre personalizado.

Una vez que completes este proyecto, deberías comprender cómo crear tu propia acción de contenedor Docker y probarla en un flujo de trabajo.

Los ejecutores autohospedados deben usar un sistema operativo Linux y tener Docker instalado para ejecutar acciones de contenedor de Docker. Para más información sobre los requisitos de los ejecutores autohospedados, consulta [Referencia de ejecutores autohospedados](/es/actions/reference/runners/self-hosted-runners#requirements-for-self-hosted-runner-machines).

> \[!WARNING]
> Al crear flujos de trabajo y acciones, siempre debe considerar si su código podría ejecutar entradas no confiables procedentes de posibles atacantes. Se tratará a algunos contextos como una entrada no confiable, ya que un atacante podrían insertar su propio contenido malintencionado. Para más información, consulta [Referencia de uso seguro](/es/actions/reference/security/secure-use#good-practices-for-mitigating-script-injection-attacks).

## Requisitos previos

* Debe crear un repositorio en GitHub y clonarlo en la estación de trabajo. Para más información, consulta [Crear un repositorio nuevo](/es/repositories/creating-and-managing-repositories/creating-a-new-repository) y [Clonar un repositorio](/es/repositories/creating-and-managing-repositories/cloning-a-repository).
* Si el repositorio usa Git LFS, debe incluir los objetos en los archivos del repositorio. Para más información, consulta [Administrar los objetos de LFS de Git en los archivos de tu repositorio](/es/enterprise-cloud@latest/repositories/managing-your-repositorys-settings-and-features/managing-repository-settings/managing-git-lfs-objects-in-archives-of-your-repository).
* Puede resultarle útil tener una comprensión básica de GitHub Actions, las variables de entorno y el sistema de archivos del contenedor Docker. Para más información, consulta [Almacenamiento de información en variables](/es/actions/how-tos/write-workflows/choose-what-workflows-do/use-variables) y [Referencia de ejecutores hospedados en GitHub](/es/actions/reference/runners/github-hosted-runners#docker-container-filesystem).

## Crear un Dockerfile

En el nuevo directorio `hello-world-docker-action`, cree un archivo `Dockerfile`. Asegúrese de que en el nombre de archivo se usen las mayúsculas adecuadas (una `D` mayúscula pero no una `f` mayúscula) en caso de que tenga problemas. Para más información, consulta [Soporte de Dockerfile para Acciones de GitHub](/es/actions/reference/workflows-and-actions/dockerfile-support).

**Dockerfile**

```dockerfile copy
# Container image that runs your code
FROM alpine:3.10

# Copies your code file from your action repository to the filesystem path `/` of the container
COPY entrypoint.sh /entrypoint.sh

# Code file to execute when the docker container starts up (`entrypoint.sh`)
ENTRYPOINT ["/entrypoint.sh"]
```

## Crear un archivo de metadatos de una acción

Cree un archivo `action.yml` en el directorio `hello-world-docker-action` que ha creado antes. Para más información, consulta [Guía de referencia de la sintaxis de metadatos](/es/actions/reference/workflows-and-actions/metadata-syntax).

**action.yml**

```yaml copy
# action.yml
name: 'Hello World'
description: 'Greet someone and record the time'
inputs:
  who-to-greet:  # id of input
    description: 'Who to greet'
    required: true
    default: 'World'
outputs:
  time: # id of output
    description: 'The time we greeted you'
runs:
  using: 'docker'
  image: 'Dockerfile'
  args:
    - ${{ inputs.who-to-greet }}
```

Estos metadatos definen un parámetro de entrada `who-to-greet` y uno de salida `time`. Para pasar entradas al contenedor de Docker, debe declarar la entrada mediante `inputs` y pasarla en la palabra clave `args`. Todo lo que incluya en `args` se pasa al contenedor, pero para que a los usuarios les resulte más sencillo descubrir la acción, se recomienda usar campos de entrada.

GitHub creará una imagen a partir de `Dockerfile` y ejecutará comandos en un nuevo contenedor usando esta imagen.

## Escribir el código de la acción

Puedes elegir cualquier imagen de Docker base y, por lo tanto, cualquier idioma para tu acción. En el ejemplo de script del shell siguiente se usa la variable de entrada `who-to-greet` para imprimir "Hello \[a\_quien\_se\_salude]" en el archivo de registro.

A continuación, el script obtiene la hora actual y la establece como una variable de salida que pueden usar las acciones que se ejecutan posteriormente en un trabajo. Para que GitHub reconozca variables de salida, debe escribirlas en el archivo de `$GITHUB_OUTPUT` entorno: `echo "<output name>=<value>" >> $GITHUB_OUTPUT`. Para más información, consulta [Comandos de flujo de trabajo para Acciones de GitHub](/es/actions/reference/workflows-and-actions/workflow-commands#setting-an-output-parameter).

1. Cree un nuevo archivo `entrypoint.sh` en el directorio `hello-world-docker-action`.

2. Agregue el código siguiente al archivo `entrypoint.sh`.

**entrypoint.sh**

```shell copy
#!/bin/sh -l

echo "Hello $1"
time=$(date)
echo "time=$time" >> $GITHUB_OUTPUT

```

Si `entrypoint.sh` se ejecuta sin errores, el estado de la acción se establece en `success`. También puedes establecer explícitamente códigos de salida en el código de tu acción para proporcionar el estado de una acción. Para más información, consulta [Establecimiento de códigos de salida para acciones](/es/actions/how-tos/create-and-publish-actions/set-exit-codes).

1. Convierte el archivo `entrypoint.sh` en ejecutable. Git proporciona una manera de cambiar explícitamente el modo de permiso de un archivo para que no se restablezca cada vez que haya una bifurcación o clonación.

   ```shell copy
   git add entrypoint.sh
   git update-index --chmod=+x entrypoint.sh
   ```

2. Opcionalmente, para comprobar el modo de permiso del archivo en el índice de Git, ejecute el siguiente comando.

   ```shell copy
   git ls-files --stage entrypoint.sh
   ```

   Una salida como `100755 e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 0       entrypoint.sh` significa que el archivo tiene el permiso ejecutable. En este ejemplo, `755` indica el permiso ejecutable.

## Crear un README

Puedes crear un archivo README para que las personas sepan cómo usar tu acción. Un archivo README resulta más útil cuando planificas el intercambio de tu acción públicamente, pero también es una gran manera de recordarle a tu equipo cómo usar la acción.

En el directorio `hello-world-docker-action`, cree un archivo `README.md` que especifique la información siguiente:

* Una descripción detallada de lo que hace la acción.
* Los argumentos de entrada y salida obligatorios.
* Los argumentos de entrada y salida opcionales.
* Los secretos que usa la acción.
* Las variables de entorno que usa la acción.
* Un ejemplo de cómo usar la acción en un flujo de trabajo.

**README.md**

```markdown copy
# Hello world docker action

This action prints "Hello World" or "Hello" + the name of a person to greet to the log.

## Inputs

## `who-to-greet`

**Required** The name of the person to greet. Default `"World"`.

## Outputs

## `time`

The time we greeted you.

## Example usage

uses: actions/hello-world-docker-action@v2
with:
  who-to-greet: 'Mona the Octocat'
```

## Confirmación, etiquetado e inserción de una acción

Desde el terminal, confirme los archivos `action.yml`, `entrypoint.sh`, `Dockerfile` y `README.md`.

También es recomendable agregar una etiqueta de versión para los lanzamientos de tu acción. Para más información sobre el control de versiones de la acción, consulta [Administración de acciones personalizadas](/es/actions/how-tos/create-and-publish-actions/manage-custom-actions#using-release-management-for-actions).

```shell copy
git add action.yml entrypoint.sh Dockerfile README.md
git commit -m "My first action is ready"
git tag -a -m "My first action release" v1
git push --follow-tags
```

## Probar tu acción en un flujo de trabajo

Ahora estás listo para probar tu acción en un flujo de trabajo.

* Cuando una acción está en un repositorio privado, puedes controlar quién puede acceder a ella. Para más información, consulta [Administración de la configuración de Acciones de GitHub para un repositorio](/es/repositories/managing-your-repositorys-settings-and-features/enabling-features-for-your-repository/managing-github-actions-settings-for-a-repository#allowing-access-to-components-in-a-private-repository).
* Cuando una acción se encuentra en un repositorio interno, la acción solo se puede usar en flujos de trabajo del mismo repositorio.
* Los flujos de trabajo de cualquier repositorio pueden usar acciones públicas.

### Ejemplo usando una acción pública

En el código de flujo de trabajo siguiente se usa la acción *hello world* completada en el repositorio público [`actions/hello-world-docker-action`](https://github.com/actions/hello-world-docker-action). Copie el código de ejemplo de flujo de trabajo siguiente en un archivo `.github/workflows/main.yml`, pero reemplace `actions/hello-world-docker-action` por el repositorio y el nombre de la acción. También puede reemplazar la entrada `who-to-greet` por su nombre.
Las acciones públicas se pueden usar aunque no se publiquen en GitHub Marketplace. Para más información, consulta [Publicar acciones en GitHub Marketplace](/es/actions/how-tos/create-and-publish-actions/publish-in-github-marketplace#publishing-an-action).

**.github/workflows/main.yml**

```yaml copy
on: [push]

jobs:
  hello_world_job:
    runs-on: ubuntu-latest
    name: A job to say hello
    steps:
      - name: Hello world action step
        id: hello
        uses: actions/hello-world-docker-action@v2
        with:
          who-to-greet: 'Mona the Octocat'
      # Use the output from the `hello` step
      - name: Get the output time
        run: echo "The time was ${{ steps.hello.outputs.time }}"
```

### Ejemplo usando una acción privada

Copie el código de flujo de trabajo de ejemplo siguiente en un archivo `.github/workflows/main.yml` del repositorio de la acción. También puede reemplazar la entrada `who-to-greet` por su nombre.
Esta acción privada no se puede publicar en GitHub Marketplace y solo puede usarse en este repositorio.

**.github/workflows/main.yml**

```yaml copy
on: [push]

jobs:
  hello_world_job:
    runs-on: ubuntu-latest
    name: A job to say hello
    steps:
      # To use this repository's private action,
      # you must check out the repository
      - name: Checkout
        uses: actions/checkout@v6
      - name: Hello world action step
        uses: ./ # Uses an action in the root directory
        id: hello
        with:
          who-to-greet: 'Mona the Octocat'
      # Use the output from the `hello` step
      - name: Get the output time
        run: echo "The time was ${{ steps.hello.outputs.time }}"
```

En el repositorio, haga clic en la pestaña **Actions** y seleccione la última ejecución de flujo de trabajo. En **Jobs** o en el gráfico de visualización, haga clic en **A job to say hello**.

En el registro, debería ver el **paso de acción Hola mundo** y debería ver "Hello Mona the Octocat", o el nombre que haya usado para la entrada `who-to-greet` impreso en el registro. Para ver la marca de tiempo, haz clic en **Obtener la hora de salida**.

## Acceso a los archivos creados por una acción de contenedor

Cuando se ejecuta una acción de contenedor, asignará automáticamente el directorio de trabajo predeterminado (`GITHUB_WORKSPACE`) en el ejecutor con el directorio `/github/workspace` del contenedor. Los archivos agregados a este directorio en el contenedor estarán disponibles para los pasos posteriores del mismo trabajo. Por ejemplo, si tiene una acción de contenedor que compila el proyecto y desea cargar la salida de compilación como un artefacto, puede seguir estos pasos.

**workflow\.yml**

```yaml copy
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v6

      # Output build artifacts to /github/workspace on the container.
      - name: Containerized Build
        uses: ./.github/actions/my-container-action

      - name: Upload Build Artifacts
        uses: actions/upload-artifact@v4
        with:
          name: workspace_artifacts
          path: ${{ github.workspace }}
```

Para obtener más información sobre cómo cargar la salida de compilación como un artefacto, consulta [Almacenamiento y uso compartido de datos con artefactos de flujo de trabajo](/es/actions/tutorials/store-and-share-data).

## Acciones de contenedor de Docker de ejemplo en GitHub.com

Puede encontrar muchos ejemplos de acciones de contenedor de Docker en GitHub.com.

* [github/issue-metrics](https://github.com/github/issue-metrics)
* [microsoft/infersharpaction](https://github.com/microsoft/infersharpaction)
* [microsoft/ps-docs](https://github.com/microsoft/ps-docs)