IBM Cloud Docs
Automatizar acciones de proyectos en tu repositorio Git

Automatizar acciones de proyectos en tu repositorio Git

En este tutorial, aprenderá cómo configurar una canalización para activar una actualización en su proyecto cuando los cambios de configuración se fusionan con la rama principal de su repositorio. Al completar este tutorial, aprenderá a automatizar tareas comunes en un proyecto, como validar una configuración, mediante el uso de las canalizaciones y cadenas de herramientas que elija.

Esta es una función experimental que está disponible para fines de evaluación y prueba y puede cambiar sin previo aviso.

Este tutorial se centra en un caso de uso simple de actualización de una configuración en un proyecto cuando los cambios se fusionan con la rama principal de su repositorio, como se ilustra en la siguiente imagen:

 La imagen muestra una actualización que va del proyecto a una rama lateral en el repositorio. Luego, una flecha indica que la rama lateral se fusiona con la rama principal, lo que activa la canalización de CD. La tubería de CD incluye un disparador para actualizar las configuraciones de su proyecto en función de las actualizaciones en su rama principal.
Actualiza automáticamente su proyecto después de que los cambios se fusionen en su rama principal

Dado que las canalizaciones y las cadenas de herramientas son personalizables, los principios de este tutorial pueden ayudarlo a automatizar otras acciones comunes dentro de un proyecto, como validar e implementar cambios de configuración después de que se fusionen con la rama principal en su repositorio. Este tutorial utiliza acciones y flujos de trabajo GitHub para automatizar una canalización entre el repositorio y el proyecto. A medida que complete el tutorial, adapte cada paso para que coincida con los procesos y pipelines de CI y CD de su repositorio.

Puede validar e implementar configuraciones de borrador solo después de que se fusionen con la rama en su repositorio que administra sus canalizaciones de CD. También debe sincronizar las actualizaciones de su repositorio en su proyecto actualizando las configuraciones antes de poder validar e implementar esas configuraciones. Puede automatizar esta actualización utilizando el método API project.config.update (como se describe en este tutorial) o utilizando el comando CLI ibmcloud project config-update.

Antes de empezar

  1. Asegúrese de tener el rol de Editor en el servicio de Proyectos de IBM Cloud.
  2. Complete los pasos para conectar su proyecto a un repositorio Git. Para los propósitos de este tutorial, conecte un proyecto vacío a un repositorio GitHub.

Agregar secretos y variables a GitHub

Crea secretos y variables en el repositorio GitHub que conectaste a tu proyecto. Estos secretos y variables se utilizan en el flujo de trabajo GitHub. Agregue los siguientes secretos y variables:

  1. Para autenticarte con tu proyecto, debes incluir una clave API IBM Cloud en tu flujo de trabajo GitHub. Para mantener segura la clave API, complete los pasos para crear un secreto para un repositorio para guardar la clave API como secreto en GitHub. Para los propósitos de este tutorial, nombre el secreto IBM_CLOUD_API_KEY.

  2. A continuación, complete los pasos para crear variables de configuración para su repositorio GitHub. Guarde las siguientes variables:

    Lista de variables para guardar en tu repositorio GitHub
    Nombre de variable Valor Descripción
    CONFIG_FOLDER_PATH configs La ruta a la carpeta del repositorio que está conectada a su proyecto. Esta carpeta contiene los archivos de configuración de su proyecto.
    IAM_URL https://iam.cloud.ibm.com URL a Cloud Identity and Access Management.
    PROJECTS_API_BASE_URL https://projects.api.cloud.ibm.com La URL de la API del proyecto.

Creando un flujo de trabajo en GitHub

Complete los pasos para escribir un flujo de trabajo en el repositorio GitHub que conectó a su proyecto.

Comience con un archivo de flujo de trabajo de ejemplo que puede modificar según sea necesario en GitHub.

Puede personalizar el flujo de trabajo con cualquier cantidad de trabajos que necesite. Sin embargo, es necesario incluir el siguiente código para actualizar correctamente las configuraciones en su proyecto cuando los cambios se fusionan desde una rama secundaria a la rama principal de su repositorio:

  1. Agregue types: [closed] a la sección on del flujo de trabajo para activar el flujo de trabajo cuando se cierra una solicitud de extracción a la rama principal:

       # Controls when the workflow will run
       on:
         # Triggers the workflow on push or pull request events but only for the "main" branch
         # push:
         #   branches: [ "main" ]
         pull_request:
           branches: [ "main" ]
           types: [closed]
    
  2. Agregue una declaración if que active este flujo de trabajo cuando los cambios se fusionen con la rama principal:

    jobs:
      update-config:
        if: github.event.pull_request.merged == true
        runs-on: ubuntu-latest
    
  3. Incluya el siguiente código en el flujo de trabajo para que su repositorio pueda conectarse a su proyecto, donde IBM_CLOUD_API_KEY es el nombre del secreto que agregó a GitHub:

      IAM_TOKEN=$(curl -X POST "https://iam.test.cloud.ibm.com/identity/token" \
            -H "Content-Type: application/x-www-form-urlencoded" \
             -H "Accept: application/json" \
             -d "grant_type=urn:ibm:params:oauth:grant-type:apikey&apikey=${{ secrets.IBM_CLOUD_API_KEY }}" | jq -r .access_token)
    
  4. Incluya el siguiente código para identificar qué configuraciones se editaron:

              # get files changed in the PR
              changed_files=$(git diff --name-only HEAD^ HEAD)
              echo "Changed files: $changed_files"
    
              for file in $changed_files; do
                # find config files that were changed
                if [[ "${file}" == ${{ vars.CONFIG_FOLDER_PATH }}/* ]] && [ -s "${file}" ]; then
                  echo "Config file updated: ${file}"
    
                  # extract data from config files
                  PROJECT_ID=$(jq -r '.project_id' $file)
                  CONFIG_ID=$(jq -r '.config_id' $file)
                  DEF=$(jq '.definition' $file)
    
                  echo "Project ID: ${PROJECT_ID}"
                  echo "Config ID: ${CONFIG_ID}"
    
  5. Incluya el siguiente código para actualizar las configuraciones editadas en su proyecto:

                  # update config definition
                  RESPONSE=$(curl -X PATCH "${BASE_URL}/v1/projects/${PROJECT_ID}/configs/${CONFIG_ID}" \
                  --header "Authorization: Bearer ${IAM_TOKEN}" \
                  --header "Accept: application/json" \
                  --header "Content-Type: application/json" \
                  --data "{ \"definition\": ${DEF} }")
    

Ejemplo de archivo de flujo de trabajo

El siguiente fragmento de código se puede utilizar como plantilla para su archivo de flujo de trabajo:

name: Projects Git Integration Workflow

# Controls when the workflow will run
on:
  # Triggers the workflow on push or pull request events but only for the "main" branch
  pull_request:
    branches: [ "main" ]
    types: [closed]

  # Allows you to run this workflow manually from the Actions tab
  workflow_dispatch:

jobs:
  update-configs:
    if: github.event.pull_request.merged == true
    runs-on: ubuntu-latest
    steps:
      # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Update Project Configs
        run: |
          IAM_TOKEN=$(curl -X POST "${{ vars.IAM_URL }}/identity/token" \
          -H "Content-Type: application/x-www-form-urlencoded" \
          -H "Accept: application/json" \
          -d "grant_type=urn:ibm:params:oauth:grant-type:apikey&apikey=${{ secrets.IBM_CLOUD_API_KEY }}" | jq -r .access_token)

          BASE_URL=${{ vars.PROJECTS_API_BASE_URL }}

          # get files changed in the PR
          changed_files=$(git diff --name-only HEAD^ HEAD)
          echo "Changed files: $changed_files"

          for file in $changed_files; do
            # find config files that were changed
            if [[ "${file}" == ${{ vars.CONFIG_FOLDER_PATH }}/* ]] && [ -s "${file}" ]; then
              echo "Config file updated: ${file}"

              # extract data from config files
              PROJECT_ID=$(jq -r '.project_id' $file)
              CONFIG_ID=$(jq -r '.config_id' $file)
              DEF=$(jq '.definition' $file)

              echo "Project ID: ${PROJECT_ID}"
              echo "Config ID: ${CONFIG_ID}"

              # update config definition
              RESPONSE=$(curl -X PATCH "${BASE_URL}/v1/projects/${PROJECT_ID}/configs/${CONFIG_ID}" \
              --header "Authorization: Bearer ${IAM_TOKEN}" \
              --header "Accept: application/json" \
              --header "Content-Type: application/json" \
              --data "{ \"definition\": ${DEF} }")

              echo $RESPONSE
              ERR_CODE=$(echo $RESPONSE | jq '.code')
              if [ "${ERR_CODE}" != "null" ]; then
                exit 1
              fi
            else
              echo "Not a project configuration file: ${file}"
            fi
          done

Probando el flujo de trabajo

Ahora que su flujo de trabajo está creado en GitHub, asegúrese de que se ejecute correctamente agregando una configuración al proyecto. Complete los pasossiguientes:

  1. En la consola IBM Cloud, haga clic en el ícono del menú de navegación Ícono del menú de navegación > Proyectos y seleccione el proyecto que está conectado a su repositorio GitHub.

  2. Haga clic en Crear para agregar una configuración a su proyecto. Asegúrese de seleccionar una rama lateral donde se guardará su configuración.

  3. Edite la configuración. Por ejemplo, agregue un método de autenticación en el panel Configurar.

  4. Seleccione la rama lateral donde desea confirmar sus cambios.

  5. Pulse Confirmar.

  6. Vaya a su repositorio GitHub y abra una solicitud de extracción para fusionar la rama secundaria en la rama principal de su repositorio.

  7. Verifique que su flujo de trabajo se ejecute cuando la rama lateral se fusione con la principal. Puedes verificarlo en el repositorio GitHub y el proyecto:

    1. En el repositorio GitHub, vaya a la pestaña Acciones y seleccione el flujo de trabajo. Verifica que la actualización se haya ejecutado correctamente.
    2. En su proyecto, haga clic en el ícono Opciones Ícono Opciones > Editar para la configuración que agregó y cambie a la rama principal. Verifique que se haya aplicado su actualización. Por ejemplo, el método de autenticación que agregó anteriormente está incluido en el panel Configurar.