4 Niveles de acciones de GitHub: una guía para la automatización del flujo de trabajo de datos

se ha convertido en un elemento indispensable para garantizar la eficiencia operativa y la confiabilidad en el desarrollo moderno de software. Las acciones de GitHub, una herramienta integrada de integración continua y implementación continua (CI/CD) dentro de GitHub, ha establecido su posición en la industria del desarrollo de software al proporcionar una plataforma integral para automatizar los flujos de trabajo de desarrollo e implementación. Sin embargo, sus funcionalidades se extienden más allá de esto … profundizaremos en el uso de acciones de GitHub dentro del ámbito del dominio de datos, lo que demuestra cómo puede optimizar los procesos para desarrolladores y profesionales de datos mediante la automatización de la recuperación de datos de fuentes externas y operaciones de transformación de datos.

Beneficios de acción de Github

Github Las acciones ya son conocidas por sus funcionalidades en el dominio de desarrollo de software, mientras que en los últimos años, también se descubren como ofreciendo beneficios convincentes en la racionalización de los flujos de trabajo de datos:

• Automatice la configuración de los entornos de ciencia de datos, como la instalación de dependencias y paquetes requeridos (por ejemplo, pandas, pytorch).
• Agilice los pasos de integración de datos y transformación de datos conectando a bases de datos para obtener o actualizar registros, y utilizando lenguajes de secuencias de comandos como Python para preprocesar o transformar los datos sin procesar.
• Cree un ciclo de vida de ciencia de datos iterable automatizando la capacitación de modelos de aprendizaje automático cada vez que hay nuevos datos disponibles e implementando modelos en entornos de producción automáticamente después de una capacitación exitosa.
• Las acciones de GitHub son gratuitas para el uso ilimitado en corredores alojados en GitHub para repositorios públicos. También proporciona 2,000 minutos gratuitos de tiempo de cómputo por mes para cuentas individuales que utilizan repositorios privados. Es fácil configurar para construir una prueba de concepto simplemente requerir una cuenta de GitHub, sin preocuparse por optar por un proveedor de nubes.
• Numerosas plantillas de acciones de GitHub y los recursos comunitarios están disponibles en línea. Además, los foros comunitarios y de crowdsourcing brindan respuestas a preguntas comunes y resolución de problemas.

Bloques de construcción de acción de Github

GitHub Action es una característica de GitHub que permite a los usuarios automatizar los flujos de trabajo directamente dentro de sus repositorios. Estos flujos de trabajo se definen utilizando archivos YAML y pueden ser activados por varios eventos, como empuje de código, solicitudes de extracción, creación de problemas o intervalos programados. Con su extensa biblioteca de acciones preconstruidas y la capacidad de escribir scripts personalizados, las acciones de GitHub es una herramienta versátil para automatizar tareas.

• Evento: Si se ha encontrado usando una automatización en sus dispositivos, como encender el modo oscuro cuando después de las 8 p.m., entonces está familiarizado con el concepto de usar un punto de activación o condición para iniciar un flujo de trabajo de acciones. En acciones de GitHub, esto se conoce como un evento, que puede estar programado para el tiempo, por ejemplo, el primer día del mes o se ejecuta automáticamente cada hora. Alternativamente, los eventos pueden ser activados por ciertos comportamientos, como cada vez que los cambios se empujan de un repositorio local a un repositorio remoto.
• Flujo de trabajo: Un flujo de trabajo está compuesto por una serie de empleos y GitHub permite la flexibilidad de personalizar cada paso individual en un trabajo a sus necesidades. Generalmente se define por un archivo YAML almacenado en el .github/workflow Directorio en un repositorio de GitHub.
• Corredores: Un entorno alojado que permite ejecutar el flujo de trabajo. En lugar de ejecutar un script en su computadora portátil, ahora puede pedir prestados corredores alojados para hacer el trabajo por usted o especificar alternativamente una máquina autohostada.
• Corre: Cada iteración de ejecutar el flujo de trabajo crea una ejecución, y podemos ver los registros de cada ejecución en la pestaña “Acciones”. GitHub proporciona una interfaz para que los usuarios visualicen y monitoreen fácilmente los registros de ejecución de acciones.

4 niveles de acciones de Github

Demostraremos las acciones de implementación de GitHub a través de 4 niveles de dificultad, comenzando con el “producto mínimo viable” e introducir progresivamente componentes y personalización adicionales en cada nivel.

1. “Flujo de trabajo simple” con la ejecución del script de Python

Comience creando un repositorio de GitHub donde desea almacenar su flujo de trabajo y el script de Python. En su repositorio, cree un .github/workflows directorio (tenga en cuenta que este directorio debe colocarse dentro del workflows carpeta para la acción que se ejecuta con éxito). Dentro de este directorio, cree un archivo YAML (por ejemplo, simple-workflow.yaml) que define su flujo de trabajo.

El archivo de flujo de trabajo muestra un archivo de flujo de trabajo que ejecuta el script de python hello_world.py basado en un disparador manual.

name: simple-workflow

on: 
    workflow_dispatch:
    
jobs:
    run-hello-world:
      runs-on: ubuntu-latest
      steps:
          - name: Checkout repo content
            uses: actions/checkout@v4
          - name: run hello world
            run: python code/hello_world.py

Consta de tres secciones: primero, name: simple-workflow Define el nombre del flujo de trabajo. Segundo, on: workflow_dispatch Especifica la condición para ejecutar el flujo de trabajo, que está desencadenando manualmente cada acción. Por último, los trabajos de flujo de trabajo jobs: run-hello-world Desglose en los siguientes pasos:

• runs-on: ubuntu-latest: Especifique el corredor (es decir, una máquina virtual) para ejecutar el flujo de trabajo – ubuntu-latest es un corredor estándar de GitHub alojado que contiene un entorno de herramientas, paquetes y configuraciones disponibles para las acciones de GitHub para usar.
• uses: actions/checkout@v4: Aplicar una acción de GitHub preconstruida checkout@v4 Para atraer el contenido del repositorio al entorno del corredor. Esto garantiza que el flujo de trabajo tenga acceso a todos los archivos y scripts necesarios almacenados en el repositorio.
• run: python code/hello_world.py: Ejecute el script de python ubicado en el code Subdirectorio ejecutando comandos de shell directamente en su archivo de flujo de trabajo YAML.

2. “Push Workflow” con la configuración del entorno

El primer flujo de trabajo demostró la versión mínima viable de la acción de GitHub, pero no aprovechó al máximo las acciones de GitHub. En el segundo nivel, agregaremos un poco más de personalización y funcionalidades: configurar automáticamente el entorno con la versión 3.11 de Python, instalar los paquetes requeridos y ejecutar el script cada vez que los cambios se empujen a la rama principal.

name: push-workflow

on: 
    push:
        branches:
            - main

jobs:
    run-hello-world:
      runs-on: ubuntu-latest
      steps:
          - name: Checkout repo content
            uses: actions/checkout@v4
          - name: Set up Python
            uses: actions/setup-python@v5
            with:
              python-version: '3.11' 
          - name: Install dependencies
            run: |
              python -m pip install --upgrade pip
              pip install -r requirements.txt
          - name: Run hello world
            run: python code/hello_world.py

• on: push: En lugar de ser activado por el despacho de flujo de trabajo manual, esto permite que la acción se ejecute siempre que haya un empuje desde el repositorio local al repositorio remoto. Esta condición se usa comúnmente en una configuración de desarrollo de software para procesos de integración e implementación, que también se adopta en el Mlops El flujo de trabajo, asegurando que los cambios en el código se prueben y validen constantemente antes de fusionarse en una rama diferente. Además, facilita la implementación continua al implementar automáticamente actualizaciones en entornos de producción o estadificación tan pronto como se impulsan los cambios. Aquí agregamos una condición opcional branches: -main solo activar esta acción cuando se empuja a la rama principal.
• uses: actions/setup-python@v5: Agregamos el paso “Configurar Python” usando la acción incorporada de GitHub setup-python@v5. Usando el setup-python La acción es la forma recomendada de usar Python con acciones de GitHub porque garantiza un comportamiento consistente en diferentes corredores y versiones de Python.
• pip install -r requirements.txt: Simplificado la instalación de paquetes requeridos para el entorno, que se guardan en el requirements.txt Archivo, por lo tanto, acelera la construcción adicional de la tubería de datos y la solución de ciencia de datos.

Si está interesado en los conceptos básicos de establecer un entorno de desarrollo para sus proyectos de ciencia de datos, mi publicación de blog anterior “7 consejos para proyectos de aprendizaje automático a prueba de futuro“Proporciona un poco más de explicación.

3. “Flujo de trabajo programado” con análisis de argumentos

En el tercer nivel, agregamos más dinámica y complejidad para que sea más adecuada para aplicaciones del mundo real. Introducimos trabajos programados, ya que aportan aún más beneficios a un proyecto de ciencia de datos, permitiendo la obtención periódica de datos más recientes y reduciendo la necesidad de ejecutar manualmente el script cada vez que se requiere actualización de datos. Además, utilizamos el análisis de argumentos dinámicos para ejecutar el script basado en diferentes parámetros de rango de fechas de acuerdo con el cronograma.

name: scheduled-workflow

on: 
    workflow_dispatch:
    schedule:
        - cron: "0 12 1 * *" # run 1st day of every month

jobs:
    run-data-pipeline:
        runs-on: ubuntu-latest
        steps:
            - name: Checkout repo content
              uses: actions/checkout@v4
            - name: Set up Python
              uses: actions/setup-python@v5
              with:
                python-version: '3.11'  # Specify your Python version here
            - name: Install dependencies
              run: |
                python -m pip install --upgrade pip
                python -m http.client
                pip install -r requirements.txt
            - name: Run data pipeline
              run: |
                  PREV_MONTH_START=$(date -d "`date +%Y%m01` -1 month" +%Y-%m-%d)
                  PREV_MONTH_END=$(date -d "`date +%Y%m01` -1 day" +%Y-%m-%d)
                  python code/fetch_data.py --start $PREV_MONTH_START --end $PREV_MONTH_END
            - name: Commit changes
              run: |
                  git config user.name '<github-actions>'
                  git config user.email '<[email protected]>'
                  git add .
                  git commit -m "update data"
                  git push

• on: schedule: - cron: "0 12 1 * *": Especifique un desencadenante basado en el tiempo usando la expresión cron “0 12 1 * *”: se ejecute a las 12:00 pm en el primer día de cada mes. Puedes usar crontab.guru Para ayudar a crear y validar las expresiones de Cron, que siguen el formato: “Minuto/Hora/Día del Mes/Mes/Día de la Semana”.
• python code/fetch_data.py --start $PREV_MONTH_START --end $PREV_MONTH_END: El paso “Ejecutar Data Pipeline” ejecuta una serie de comandos de shell. Define dos variables PREV_MONTH_START y PREV_MONTH_END Para obtener el primer día y el último día del mes anterior. Estas dos variables se pasan al script de Python “fetch_data.py” para obtener datos dinámicamente para el mes anterior en relación con cuando se ejecute la acción. Para permitir que el script de Python acepte variables personalizadas a través de argumentos de línea de comandos, usamos argparse Biblioteca para construir el script. Esto merece un tema separado, pero aquí hay una vista previa rápida de cómo se vería el script de Python usando el argparse Biblioteca para manejar los argumentos de la línea de comandos ‘–Star’ y ‘–Ed’ parámetros.

## fetch_data.py

import argparse
import os
import urllib

def main(args=None):
	  parser = argparse.ArgumentParser()
	  parser.add_argument('--start', type=str)
	  parser.add_argument('--end', type=str)
	  args = parser.parse_args(args=args)
	  print("Start Date is: ", args.start)
	  print("End Date is: ", args.end)
	  
	  date_range = pd.date_range(start=args.start, end=args.end)
	  content_lst = []
	
	  for date in date_range:
	      date = date.strftime('%Y-%m-%d')
	
		  params = urllib.parse.urlencode({
	          'api_token': '<NEWS_API_TOKEN>',
	          'published_on': date,
	          'search': search_term,
	      })
		  url = '/v1/news/all?{}'.format(params)
		    
		  content_json = parse_news_json(url, date)
		  content_lst.append(content_json)

	  with open('data.jsonl', 'w') as f:
	      for item in content_lst:
	          json.dump(item, f)
	          f.write('\n')
	  
      return content_lst

Cuando el comando python code/fetch_data.py --start $PREV_MONTH_START --end $PREV_MONTH_END ejecuta, crea un rango de fecha entre $PREV_MONTH_START y $PREV_MONTH_END. Para cada día en el rango de fechas, genera una URL, obtiene las noticias diarias a través de la API, analiza la respuesta JSON y recopila todo el contenido en una lista de JSON. Luego generamos esta lista de JSON al archivo “data.jsonl”.

- name: Commit changes
  run: |
      git config user.name '<github-actions>'
      git config user.email '<[email protected]>'
      git add .
      git commit -m "update data"
      git push

Como se muestra anteriormente, el último paso “cambios de confirmación” confirma los cambios, configura el correo electrónico y el nombre del usuario de GIT, organiza los cambios, los compromete y los empuja al repositorio remoto de GitHub. Este es un paso necesario al ejecutar acciones de GitHub que dan como resultado cambios en el directorio de trabajo (por ejemplo, se crea el archivo de salida “data.jsonl”). De lo contrario, la salida solo se guarda en el /temp Carpeta dentro del entorno del corredor, y parece que no se han realizado cambios después de que se complete la acción.

4. “Flujo de trabajo seguro” con secretos y gestión de variables de entorno

El nivel final se centra en mejorar la seguridad y el rendimiento del flujo de trabajo GitHub al abordar los requisitos no funcionales.

name: secure-workflow

on: 
    workflow_dispatch:
    schedule:
        - cron: "34 23 1 * *" # run 1st day of every month

jobs:
    run-data-pipeline:
        runs-on: ubuntu-latest
        steps:
            - name: Checkout repo content
              uses: actions/checkout@v4
            - name: Set up Python
              uses: actions/setup-python@v5
              with:
                python-version: '3.11'  # Specify your Python version here
            - name: Install dependencies
              run: |
                python -m pip install --upgrade pip
                python -m http.client
                pip install -r requirements.txt
            - name: Run data pipeline
              env:
                  NEWS_API_TOKEN: ${{ secrets.NEWS_API_TOKEN }} 
              run: |
                  PREV_MONTH_START=$(date -d "`date +%Y%m01` -1 month" +%Y-%m-%d)
                  PREV_MONTH_END=$(date -d "`date +%Y%m01` -1 day" +%Y-%m-%d)
                  python code/fetch_data.py --start $PREV_MONTH_START --end $PREV_MONTH_END
            - name: Check changes
              id: git-check
              run: |
                  git config user.name 'github-actions'
                  git config user.email '[email protected]'
                  git add .
                  git diff --staged --quiet || echo "changes=true" >> $GITHUB_ENV
            - name: Commit and push if changes
              if: env.changes == 'true'
              run: |
                  git commit -m "update data"
                  git push
                  

Para mejorar la eficiencia del flujo de trabajo y reducir los errores, agregamos una verificación antes de cometer cambios, asegurando que los compromisos y los empujes solo ocurran cuando existen cambios reales desde la última confirmación. Esto se logra a través del comando git diff --staged --quiet || echo "changes=true" >> $GITHUB_ENV.

• git diff --staged Verifica la diferencia entre el área de puesta en escena y la última confirmación.
• --quiet suprime la salida: devuelve 0 cuando no hay cambios entre el entorno escenificado y el directorio de trabajo; mientras que devuelve el código de salida 1 (error general) cuando hay cambios entre el entorno escenificado y el directorio de trabajo
• Este comando se conecta a echo "changes=true" >> $GITHUB_ENV a través del operador || Lo que le dice al shell que ejecute el resto de la línea si el primer comando falló. Por lo tanto, si existen cambios, “cambios = verdadero” se pasa a la variable de entorno $GITHUB_ENV y accedido en el siguiente paso para activar Git Commit y Push Condicionado env.changes == 'true'.

Por último, presentamos el secreto del medio ambiente, lo que mejora la seguridad y evita exponer información confidencial (p. Ej., Token API, token de acceso personal) en la base de código. Además, los secretos del medio ambiente ofrecen el beneficio de separar el entorno de desarrollo. Esto significa que puede tener diferentes secretos para diferentes etapas de su canalización de desarrollo e implementación. Por ejemplo, el entorno de prueba (por ejemplo, en la rama de desarrollo) solo puede acceder al token de prueba, mientras que el entorno de producción (por ejemplo, en la rama principal) podrá acceder al token vinculado a la instancia de producción.

Para configurar secretos ambientales en GitHub:

1. Vaya a la configuración de su repositorio
2. Navegar a secretos y variables> acciones
3. Haga clic en “Nuevo secreto de repositorio”
4. Agregue su nombre y valor secreto

Después de configurar los secretos del entorno de GitHub, necesitaremos agregar el secreto al entorno de flujo de trabajo, por ejemplo a continuación, agregamos ${{ secrets.NEWS_API_TOKEN }} al paso “Ejecutar la tubería de datos”.

- name: Run data pipeline
  env:
      NEWS_API_TOKEN: ${{ secrets.NEWS_API_TOKEN }} 
  run: |
      PREV_MONTH_START=$(date -d "`date +%Y%m01` -1 month" +%Y-%m-%d)
      PREV_MONTH_END=$(date -d "`date +%Y%m01` -1 day" +%Y-%m-%d)
      python code/fetch_data.py --start $PREV_MONTH_START --end $PREV_MONTH_END

Luego actualizamos el script de Python fetch_data.py Para acceder al secreto del medio ambiente utilizando os.environ.get().

import os api_token = os.environ.get('NEWS_API_TOKEN')

Mensaje para llevar a casa

Esta guía explora la implementación de acciones de GitHub para construir tuberías de datos dinámicos, progresando a través de cuatro niveles diferentes de implementaciones de flujo de trabajo:

• Nivel 1: Configuración básica de flujo de trabajo con desencadenantes manuales y ejecución simple de script de Python.
• Nivel 2: Empuje el flujo de trabajo con la configuración del entorno de desarrollo.
• Nivel 3: flujo de trabajo programado con manejo dinámico de fechas y recaudación de datos con argumentos de línea de comandos
• Nivel 4: Flujo de trabajo seguro de tuberías con secretos y variables de entorno de gestión

Cada nivel se basa en el anterior, lo que demuestra cómo las acciones de GitHub se pueden utilizar de manera efectiva en el dominio de datos para optimizar las soluciones de datos y acelerar el ciclo de vida del desarrollo.