Automatice los flujos de trabajo de desarrollo de software con Github Actions 🚀 | por Ansh Sachdeva

Créditos: clouddefence.ai

  • GitHub Actions es una plataforma de integración continua y entrega continua (CI/CD) que nos permite automatizar su proceso de compilación, prueba e implementación.
  • Podemos crear flujos de trabajo que creen y prueben cada solicitud de extracción para nuestro repositorio o implementen solicitudes de extracción combinadas en producción. Hay muchos casos de uso y eventos que podemos combinar para obtener los resultados que queremos.

En resumen, definimos un conjunto de comandos en un archivo y los insertamos en nuestro código. Cuando Github identifica este archivo, ejecuta estos comandos en un dispositivo en la nube que aloja nuestro código.

  1. Flujo de trabajo: un flujo de trabajo es un archivo .yml (obtenga más información sobre su sintaxis aquí.) archivo que agregamos en la carpeta .github/workflows y verificamos en nuestro repositorio de proyectos. Consiste en una serie de trabajos que se ejecutan en nuestro código cuando se desencadenan por un evento. Estos trabajos también se pueden activar manualmente. Podemos tener múltiples flujos de trabajo en nuestro proyecto
  2. Evento: un evento es una actividad específica en un repositorio que desencadena la ejecución del flujo de trabajo. Por ejemplo, un activador puede provenir de GitHub cuando alguien crea una solicitud de extracción, abre una propuesta o envía una confirmación a un repositorio. También puede desencadenar la ejecución de un flujo de trabajo según un cronograma, mediante la publicación en una API REST o manualmente. En esta lista encontrarás todos los eventos:

3. Trabajos: Los trabajos son una serie de pasos que se realizan secuencialmente en el mismo corredor. Un flujo de trabajo define 1 o más trabajos y en un trabajo definimos 1 o más pasos. Cada trabajo se ejecuta en su propio contenedor y, por lo tanto, los pasos de cada trabajo se ejecutan en paralelo a menos que se configure de otra manera4. Paso: un paso es la unidad de comando más pequeña en un flujo de trabajo de Github. Cada paso es un script de shell que se ejecuta o una acción que se realiza. Los pasos se realizan en orden y dependen unos de otros. Debido a que cada paso se realiza en el mismo corredor, podemos compartir datos de un paso a otroEjemplo de un flujo de trabajo de Github. Definimos Job1, Job2 y los pasos en un flujo de trabajo. Se desencadena por un evento y los trabajos se ejecutan en paralelo.

  • Como se mencionó anteriormente, los trabajos se ejecutan en contenedores paralelos mientras que los pasos se ejecutan secuencialmente en el mismo contenedor. Por lo tanto, podemos mezclar y combinar si una tarea determinada debe ejecutarse en un trabajo separado (para que pueda ejecutarse en paralelo) o en el mismo trabajo (para que pueda ejecutarse en orden secuencial junto con otros pasos).
  • De manera predeterminada, la falla de un paso en un trabajo hace que falle todo el trabajo (a menos que se configure de otra manera), pero no afecta a los otros trabajos que se ejecutan en paralelo.

Consideremos el siguiente ejemplo:

  1. Apellido: identifica el nombre de la acción de GitHub que se muestra en el historial de ejecución de la acción
  2. en : Esta sección designa los eventos que activan los trabajos definidos en la sección de trabajos. Este bloque puede contener muchas subconfiguraciones. Por ejemplo, si queremos que el flujo de trabajo sea desencadenado por un solicitud de extracción, podemos nombrar las ramas contra las que disparar el PR. Otra subconfiguración disponible para PR es tipo: que puede tomar los valores cerrado, abierto, editado, etc. La lista completa de eventos puede ser encontrado aquí
  3. trabajos: Esta sección consta de diferentes trabajos que se ejecutan en paralelo tan pronto como ocurren los eventos mencionados en una sección. Tu nombre puede ser cualquier cosa:

trabajos: lint-static_checks-prueba-construcción: trabajo_paralelo_2: trabajo_paralelo_3:

3.1 Configuración de un pedido.

Un trabajo puede constar de muchos atributos para una configuración específica. Un ejemplo de algunos de los atributos generales se vería así:trabajos: Mi primer trabajo: permisos:Contenido: Leer paquetes: escribir se ejecuta en: [self-hosted, ubuntu-latest] Pasos: Trabajo2: sips }}necesidades: Mi primer trabajo

  1. permisos: Estos son los permisos a nivel de contenedor que proporcionaremos para nuestro trabajo. Puede haber varios tipos de permisos.
  2. se ejecuta en: Aquí definimos la máquina que se utilizará para ejecutar el trabajo
  3. si: ${{}}}: Estos son Expresiones condicionales que se ejecutan declarativamente. Las condiciones se pueden aplicar en diferentes niveles en un flujo de trabajo. Se puede usar para omitir o ejecutar todo el trabajo o solo un paso. Pero, ¿a qué afectan estas condiciones? ${{}} se puede usar para evaluar cualquier condición como ${{1+2==3}} . También hay ciertas propiedades que se generan para cada paso o trabajo, como ${{job.status == ‘success’}}. Estos se llaman contexto.
  4. necesidades: Este es un atributo que hace que diferentes trabajos que se ejecutan en paralelo se ejecuten uno tras otro. idealmente, job2 en el primer ejemplo debería ejecutarse en paralelo con my_first_job. Al usar Needs nos aseguramos de que job2 se ejecute después de my_first_job
  5. pasos: un trabajo contiene una secuencia de tareas llamadas pasos. Los pasos pueden ejecutar comandos, realizar tareas de configuración o realizar acciones en su repositorio, un repositorio público o una acción publicada en un registro de Docker. Los pasos pueden aceptar entradas (en forma de constantes) y generar salidas. Los pasos de un trabajo se ejecutan secuencialmente. De forma predeterminada, los pasos están configurados para fallar en la ejecución si el paso anterior falló o dio un resultado de error, pero este comportamiento se puede cambiar a través de Expresiones condicionales.

3.2 Estructura de un paso

pasos: – Nombre: Tarea «Configurar filtro de ruta» y «Ejecutar». Usó: dorny/paths-filter@v2me gustaría: filtroCon:filtro: |md: [‘CHANGELOG.md’] – Apellido: FALLO si no se modifican los archivos obligatoriossi: ${{pasos.filtro.salidas.md == ‘falso’ }}Usó: acciones/github-script@v3Con:guion: |core.setFailed(‘Los archivos de descuento obligatorios no han cambiado’) – Apellido: genera archivos AAR y APK.manga: golpecorrer: ./gradlew ensamblar depuración

  1. nombre: Esta es una clave opcional que da una breve descripción del paso. Si la clave de nombre está presente, se mostrará en el terminal de flujo de trabajo durante la ejecución
  2. id: esta es otra clave opcional que identifica de forma única el paso. Con esta clave podemos obtener detalles sobre el paso (sus entradas, salidas, tiempo de ejecución, etc.). aquí el segundo paso «FALLÓ si los archivos obligatorios no se modifican» utiliza la entrada del paso anterior para determinar si la acción debe realizarse a través de la sintaxis de steps.filter.* o falla
  3. usos y ejecuciones: Estas son 2 características muy importantes de un paso. un paso debe definir uno de estos dos.
  4. Cuando usamos uses, le hacemos saber al corredor que queremos ejecutar una serie de comandos escritos en una sola acción desde el mercado. Es como una biblioteca. por ejemplo filtro de caminos/dorny es una actividad popular para verificar si un archivo ha cambiado o no
  5. Cuando usamos ejecutar, le decimos al corredor que queremos ejecutar un comando específico en la máquina host. esto es como usar una terminal en nuestra propia máquina: si el comando se puede ejecutar con éxito o no depende del software ya presente en el sistema y si admitiría su ejecución. Por ejemplo: ./gradlew AssembleDebug es un comando de terminal que queremos ejecutar y solo se ejecutará correctamente si Gradle está instalado en la máquina host de forma predeterminada o como parte de los pasos secuenciales anteriores.
  6. Shell: este comando se usa junto con el comando ejecutar para informar a la máquina host del terminal que queremos usar
  7. with: este atributo se usa con pasos que solo usan acciones de terceros (a través de uses ) y les proporciona entrada. Puede pasar números, cadenas o incluso secuencias de comandos js a través de argumentos en el bloque with. Las claves están definidas por estas acciones mismas.
  8. env: este atributo es similar a with pero se usa para definir entradas para el paso en sí y se puede usar tanto con uses como con run

Dado que podemos tener múltiples flujos de trabajo en nuestro repositorio, existe la posibilidad de que usemos los mismos pasos en cada uno de ellos, lo que resultará en duplicados. Y dado que la duplicación es mala y difícil de mantener, es posible que deseemos una solución que nos permita aislar los pasos de los flujos de trabajo en una ubicación central y reutilizarlos cuando sea necesario. Aquí es donde la composición del flujo de trabajo resulta útil. Con la composición del flujo de trabajo, podemos crear archivos separados para cada paso y usarlos en cada flujo de trabajo a través de la sintaxis de usos. Los pasos son independientes del entorno del trabajo o del sistema y, por lo tanto, se pueden realizar en cualquier flujo de trabajo con muy poco esfuerzo de integración. Aquí hay un ejemplo de un flujo de trabajo que NO usa composición: si necesitamos crear 10 flujos de trabajo más usando los resultados de Check lint y Upload Lint, tendríamos que copiar manualmente todos esos comandos largos de Gradle y nombres de ruta que son propensos a errores. También sería difícil mantener 10 copias de este tipo para cambios futuros. Con la composición, este archivo se vuelve tan pequeño como esto: ¡solo se requieren 2 líneas para realizar verificaciones de pelusa y cargar resultados! Ahora podemos hacer 10 o incluso 100 copias, ¡no tenemos que preocuparnos por cometer errores en los archivos de ruta o en los comandos de Gradle! Esto se debe a que estos detalles existen en un archivo YML separado .github/mini_flows/s3_lint/action.yml con una sintaxis algo similar:

Deja una respuesta

Tu dirección de correo electrónico no será publicada.