es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Mi primer archivo .gitlab-ci.yml: Cómo ejecutar archivos existentes en CI/CD.

Suelo trabajar como matemático para construir y entrenar nuevos modelos en datos, pero quiero intentar aprender algunas cosas nuevas – así que soy un principiante absoluto en el siguiente problema. Mi tema actual de aprendizaje es cómo usar CI/CD en gitlab.
He creado un proyecto en Python en PyCharm.
Mi estructura de carpetas es la siguiente:

  • proyecto
    • Flask
    • latest_model
    • templates
    • webservice_flask.py
    • tests
    • init.py
    • test_DR.py
    • test_pred.py
    • test_train.py
    • DR.py
    • pred.py
    • train.py

Donde “…” simboliza algunos archivos no importantes, los archivos .py son archivos Python regulares y las expresiones sin un final especial son carpetas normales.
El archivo DR.py lee algunos datos, el archivo train.py entrena un modelo, el archivo pred.py hace una predicción basada en el modelo entrenado, la carpeta de pruebas contiene archivos de prueba para probar los componentes anteriores y la carpeta flask contiene un servicio web de Flask como implementación para un cliente. Hasta aquí todo bien, todo funciona bien en mi máquina local.
Ahora quiero integrar este proyecto en un pipeline CI/CD en gitlab con la siguiente estructura:

Ejecutar DR.py > ejecutar test_DR.py > ejecutar train.py > ejecutar test_train.py > ejecutar pred.py > ejecutar test_pred.py > ejecutar webservice_flask.py.

No estoy seguro si esta estructura es realista, ya que he leído que los componentes de una etapa (como las pruebas) se ejecutan en paralelo. Sé que tengo que crear un archivo .gitlab-ci.yml en la carpeta raíz de mi proyecto, para iniciar el pipeline CI/CD. La estructura del archivo (según yo entiendo) debería verse de la siguiente manera:

etapas:
  - construir
  - prueba
  - implementar

construir_base_de_datos:
  etapa: construir
  script:
    - echo "Cargar los datos"
    - #...aquí quiero ejecutar el archivo DR.py, pero no sé cómo

probar_lector_de_datos:
  etapa: prueba
  script:
    - echo "Probar los datos cargados"
    - #...aquí quiero ejecutar el archivo test_DR.py, pero no sé cómo

... y así sucesivamente con cada componente de mi pipeline.

¿Alguien puede ayudarme por favor? ¿Mis intentos iniciales son completamente absurdos? ¿Alguien puede decirme el comando para ejecutar archivos en el proyecto para el documento yaml?
¡Muchas gracias!

Tags:  , , ,

Answer

  1. Avatar for davy.ai

    Integración de un Proyecto Python en un Pipeline de CI/CD en GitLab

    Introducción

    Como experto en IT especializado en Python, GitLab, YAML y CI/CD, puedo orientarte sobre cómo integrar tu proyecto Python en un pipeline de CI/CD en GitLab. Mencionaste que eres un principiante absoluto en este tema, así que te proporcionaré instrucciones paso a paso.

    Estructura del Pipeline de CI/CD en GitLab

    La estructura para tu pipeline de CI/CD debe ser la siguiente:
    1. Cargar y preparar los datos: Ejecutar DR.py
    2. Probar la preparación de los datos: Ejecutar test_DR.py
    3. Entrenar el modelo: Ejecutar train.py
    4. Probar el entrenamiento del modelo: Ejecutar test_train.py
    5. Realizar predicciones: Ejecutar pred.py
    6. Probar las predicciones del modelo: Ejecutar test_pred.py
    7. Desplegar el servicio web Flask: Ejecutar webservice_flask.py

    Ten en cuenta que estas etapas pueden ejecutarse en paralelo según tu configuración.

    Archivo .gitlab-ci.yml

    Para inicializar el pipeline de CI/CD, debes crear un archivo .gitlab-ci.yml en la carpeta raíz de tu proyecto. Aquí tienes un ejemplo de cómo podría ser tu archivo:

    stages:
      - loadData
      - testData
      - train
      - testTrain
      - predict
      - testPredict
      - deploy
    
    load_data:
      stage: loadData
      script:
        - python DR.py
    
    test_data:
      stage: testData
      script:
        - python -m unittest tests.test_DR
    
    train_model:
      stage: train
      script:
        - python train.py
    
    test_train:
      stage: testTrain
      script:
        - python -m unittest tests.test_train
    
    predict:
      stage: predict
      script:
        - python pred.py
    
    test_predict:
      stage: testPredict
      script:
        - python -m unittest tests.test_pred
    
    deploy_flask:
      stage: deploy
      script:
        - python webservice_flask.py
    

    En este archivo, defines las etapas y para cada etapa proporcionas un script para ejecutar. El script simplemente utiliza el comando python para ejecutar el archivo Python correspondiente o la prueba unitaria. Ten en cuenta que las pruebas unitarias se ejecutan utilizando el módulo unittest. Cada etapa se ejecuta de forma independiente de las demás, por lo que puedes ejecutar múltiples etapas en paralelo si así lo deseas.

    Conclusión

    Espero que esta guía te haya sido útil para mostrar cómo integrar tu proyecto Python en un pipeline de CI/CD utilizando GitLab. Recuerda que puedes personalizar el pipeline de acuerdo a tus necesidades, pero la estructura básica es cargar y preparar datos, probar la preparación de los datos, entrenar el modelo, probar el entrenamiento del modelo, realizar predicciones, probar las predicciones del modelo y desplegar el servicio web Flask. ¡Buena suerte con tu proyecto!

Comments are closed.