Se usó la API de Cloud Translation para traducir esta página.

Conéctate a un host de GitLab Enterprise Edition

En esta página, se explica cómo conectarse al host GitLab Enterprise Edition de Cloud Build.

Antes de comenzar

Habilita las API de Cloud Build and Secret Manager.
Habilita las API

Requisitos de host

Si no instalaste una instancia de GitLab Enterprise Edition Server, consulta la guía de instalación de GitLab Enterprise Edition para obtener instrucciones.

Cuando sigas las instrucciones para instalar una instancia de GitLab Enterprise Edition Server, ten en cuenta lo siguiente:
- Debes configurar tu host para que maneje el protocolo HTTPS. Los hosts configurados con el protocolo HTTP no son compatibles.
- Debes configurar tu host con la misma URL que se usa para llegar al host desde Google Cloud. Si quieres obtener más información, consulta la documentación de GitLab para configurar la URL externa.

Permisos de IAM obligatorios

Para conectar tu host de GitLab Enterprise Edition, otorga la función de administrador de conexión de Cloud Build (roles/cloudbuild.connectionAdmin) a tu cuenta de usuario.

Para agregar los roles necesarios a tu cuenta de usuario, consulta Configura el acceso a los recursos de Cloud Build. Para obtener más información sobre las funciones de IAM asociadas con Cloud Build, consulta Funciones y permisos de IAM.

Si tu instancia de GitLab Enterprise Edition está alojada en una red privada, consulta Compila repositorios de GitLab Enterprise Edition en una red privada para obtener información sobre los roles de IAM adicionales que se requieren antes de la conexión del host.

Conéctate a un host de GitLab Enterprise Edition

Antes de crear una conexión de host para tu instancia de GitLab Enterprise Edition, debes crear tokens de acceso personal en GitLab Enterprise Edition. Para ello, completa los siguientes pasos:

Accede a tu instancia de GitLab Enterprise Edition.
En la página GitLab Enterprise Edition de tu instancia, haz clic en tu avatar en la esquina superior derecha.
Haz clic en Editar perfil.
En la barra lateral izquierda, selecciona Tokens de acceso.

Verás la página Personal Access Tokens (Tokens de acceso personal).
Crea un token de acceso con el permiso api para usarlo a fin de conectar y desconectar repositorios.
Crea un token de acceso con el permiso read_api para garantizar que los repositorios de Cloud Build puedan acceder al código fuente en los repositorios.

Nota: Además de los tokens de acceso personal, también puedes usar tokens de acceso a proyectos. Si tu versión de GitLab es 14.2 o posterior, también puedes usar tokens de acceso a grupos. Si usas tokens de acceso a un proyecto o grupo, selecciona el rol Maintainer o uno superior para garantizar una conexión exitosa.

Consola

Para conectar tu host de GitLab Enterprise Edition a Cloud Build, haz lo siguiente:

Abre la página Repositorios en la consola de Google Cloud.

Abrir la página repositorios

Verás la página Repositories (Repositorios).
En la parte superior de la página, selecciona la pestaña 2a gen..
En el selector de proyectos de la barra superior, selecciona tu proyecto de Google Cloud.
Haz clic en Crear conexión de host para conectar un host nuevo a Cloud Build.
En el panel izquierdo, selecciona GitLab como tu proveedor de origen.
En la sección Configurar conexión, ingresa la siguiente información:
1. Región: Selecciona una región para tu conexión.
  
  Nota: Debes especificar una región. Tu conexión no puede existir de manera global.
2. Nombre: Ingresa un nombre para la conexión.
En la sección Detalles del host, selecciona o ingresa la siguiente información:
1. Proveedor de GitLab: Selecciona Self-managed GitLab Enterprise Edition como tu proveedor.
2. URL del host: Ingresa la URL del host para tu conexión. Por ejemplo, https://my-gle-server.net
3. Certificado de CA: Haz clic en Navegar para subir tu certificado autofirmado.
  
  Nota: Tu certificado no debe superar los 10 KB de tamaño y debe estar en formato PEM (.pem, .cer o .crt). Si esta sección se deja en blanco, se usará un conjunto predeterminado de certificados.
4. En Tipo de conexión, selecciona una de las siguientes opciones:
  1. Internet pública: Selecciona esta opción si se puede acceder a tu instancia a través de la Internet pública.
  2. Acceso a red privada: Selecciona esta opción si tu instancia está alojada en una red privada.
  3. En Servicio del Directorio de servicios, selecciona la ubicación de tu servicio:
    - En el proyecto your-project
    - En otro proyecto
    - Ingresa los datos manualmente
    1. Si seleccionas En otro proyecto o Ingresar manualmente, ingresa la siguiente información:
      - Proyecto: Ingresa o selecciona el ID del proyecto de Google Cloud en el menú desplegable.
      - Región: Este campo preselecciona la región de tu conexión. La región especificada para el servicio debe coincidir con la región asociada con la conexión.
    2. Espacio de nombres: Selecciona el espacio de nombres de tu servicio.
    3. Servicio: Selecciona el nombre del servicio en tu espacio de nombres.
En la sección Personal access tokens, ingresa la siguiente información:
1. Token de acceso a la API: Ingresa el token con el acceso al permiso api. Este token se usa para conectar y desconectar repositorios.
2. Token de acceso a la API de lectura: Ingresa el token con el acceso de permiso read_api. Los activadores de Cloud Build usan este token para acceder al código fuente en los repositorios.
Haz clic en Conectar.

Después de hacer clic en el botón Conectar, tus tokens de acceso personal se almacenan de forma segura en Secret Manager. Después de la conexión del host, Cloud Build también crea un secreto de webhook por ti. Puedes ver y administrar Secrets en la página Secret Manager. Puedes ver y administrar tus secretos en la página Secret Manager.

Creaste correctamente una conexión de GitLab Enterprise Edition.

gcloud

Antes de conectar tu host de GitLab Enterprise Edition a Cloud Build, completa los siguientes pasos para almacenar tus credenciales:

Almacena tu token en Secret Manager.

Crea un secreto de webhook en Secret Manager mediante la ejecución del siguiente comando:

 cat /proc/sys/kernel/random/uuid | tr -d '\n' | gcloud secrets create my-gle-webhook-secret --data-file=-

Si almacenas tus secretos en un proyecto de Google Cloud diferente del que planeas usar para crear una conexión de host, ingresa el siguiente comando a fin de otorgar a tu proyecto acceso al agente de servicio de Cloud Build:
```
PN=$(gcloud projects describe PROJECT_ID --format="value(projectNumber)")
CLOUD_BUILD_SERVICE_AGENT="service-${PN}@gcp-sa-cloudbuild.iam.gserviceaccount.com"
gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="serviceAccount:CLOUD_BUILD_SERVICE_AGENT \
  --role="roles/secretmanager.admin"
```
Aquí:
- PROJECT_ID es tu ID del proyecto de Google Cloud.
- CLOUD_BUILD_SERVICE_AGENT es tu cuenta de servicio de Cloud Build.

Ahora puedes conectar tu host de GitLab Enterprise Edition a Cloud Build.

Completa los siguientes pasos:

Ingresa el siguiente comando para crear una conexión de GitLab Enterprise Edition:
```
gcloud builds connections create gitlab CONNECTION_NAME \
  --host-uri=HOST_URI \
  --project=PROJECT_ID \
  --region=REGION \
  --authorizer-token-secret-version=projects/PROJECT_ID/secrets/API_TOKEN/versions/SECRET_VERSION \
  --read-authorizer-token-secret-version=projects/PROJECT_ID/secrets/READ_TOKEN/versions/SECRET_VERSION \
  --webhook-secret-secret-version=projects/PROJECT_ID/secrets/WEBHOOK_SECRET/versions/SECRET_VERSION
```
Aquí:
- CONNECTION_NAME es el nombre de tu conexión.
- HOST_URI es el URI de tu instancia de GitLab Enterprise Edition. Por ejemplo, https://my-gle-server.net
- PROJECT_ID es tu ID del proyecto de Google Cloud.
- REGION es la región de tu conexión.
- API_TOKEN es el nombre de tu token con alcance api.
- READ_TOKEN es el nombre de tu token con alcance read_api.
- SECRET_VERSION es la versión de tu secreto.
- WEBHOOK_SECRET es tu secreto de webhook.

Creaste correctamente una conexión de GitLab Enterprise Edition.

Terraform

Puedes conectar tu host de GitLab Enterprise Edition a Cloud Build mediante Terraform.

En el siguiente ejemplo, el fragmento de código hace lo siguiente:

Configura el proveedor de Google para Terraform
Crea un secreto para almacenar tu token de acceso personal de GitLab Enterprise Edition
Otorga los permisos necesarios al agente de servicio de Cloud Build para acceder a los secretos.

Crea una conexión de GitLab Enterprise Edition

// Configure the terraform google provider
resource "google_secret_manager_secret" "api-pat-secret" {
    project = "PROJECT_ID"
    secret_id = "GITLAB_PAT_API"

    replication {
        automatic = true
     }
 }

 resource "google_secret_manager_secret_version" "api-pat-secret-version" {
     secret = google_secret_manager_secret.api-pat-secret.id
     secret_data = "GITLAB_API_TOKEN"
 }

 resource "google_secret_manager_secret" "read-pat-secret" {
     project = "PROJECT_ID"
     secret_id = "GITLAB_PAT_READ"

     replication {
         automatic = true
     }
}

resource "google_secret_manager_secret_version" "read-pat-secret-version" {
    secret = google_secret_manager_secret.pat-secret.id
    secret_data = "GITLAB_API_TOKEN"
}

resource "google_secret_manager_secret" "webhook-secret-secret" {
    project = "PROJECT_ID"
    secret_id = "WEBHOOK_SECRET"

    replication {
        automatic = true
    }
}

resource "google_secret_manager_secret_version" "webhook-secret-secret-version" {
    secret = google_secret_manager_secret.webhook-secret-secret.id
    secret_data = "WEBHOOK_SECRET_VALUE"
}

data "google_iam_policy" "serviceagent-secretAccessor" {
    binding {
        role = "roles/secretmanager.secretAccessor"
        members = ["serviceAccount:service-PROJECT_NUMBER@gcp-sa-cloudbuild.iam.gserviceaccount.com"]
    }
}

resource "google_secret_manager_secret_iam_policy" "policy-pak" {
  project = google_secret_manager_secret.private-key-secret.project
  secret_id = google_secret_manager_secret.private-key-secret.secret_id
  policy_data = data.google_iam_policy.serviceagent-secretAccessor.policy_data
}

resource "google_secret_manager_secret_iam_policy" "policy-rpak" {
  project = google_secret_manager_secret.webhook-secret-secret.project
  secret_id = google_secret_manager_secret.webhook-secret-secret.secret_id
  policy_data = data.google_iam_policy.serviceagent-secretAccessor.policy_data
}

resource "google_secret_manager_secret_iam_policy" "policy-whs" {
  project = google_secret_manager_secret.webhook-secret-secret.project
  secret_id = google_secret_manager_secret.webhook-secret-secret.secret_id
  policy_data = data.google_iam_policy.serviceagent-secretAccessor.policy_data
}

// create the connection and add the repository resource
resource "google_cloudbuildv2_connection" "my-connection" {
    project = "PROJECT_ID"
    location = "REGION"
    name = "CONNECTION_NAME"

    gitlab_config {
        authorizer_credential {
            user_token_secret_version = google_secret_manager_secret_version.pat-secret-version.id
        }
        read_authorizer_credential {
             user_token_secret_version = google_secret_manager_secret_version.pat-secret-version.id
        }
        webhook_secret_secret_version = google_secret_manager_secret_version.webhook-secret-secret-version.id
    }

    depends_on = [
        google_secret_manager_secret_iam_policy.policy-pak,
        google_secret_manager_secret_iam_policy.policy-rpak,
        google_secret_manager_secret_iam_policy.policy-whs
    ]
}

Aquí:

PROJECT_ID es tu ID del proyecto de Google Cloud.
GITLAB_PAT_API es tu token de acceso personal con acceso api.
GITLAB_API_TOKEN es tu token de acceso personal.
GITLAB_PAT_READ es tu token de acceso personal con acceso read_api.
WEBHOOK_SECRET es el nombre del secreto que contiene el valor del secreto de tu webhook.
WEBHOOK_SECRET_VALUE es el valor de tu secreto de webhook.
REGION es la región de tu conexión.
CONNECTION_NAME es el nombre de tu conexión de GitLab Enterprise Edition.
URI es el URI de la conexión. Por ejemplo, https://my-gitlab-enterprise-server.net Creaste correctamente una conexión de GitLab Enterprise Edition.

¿Qué sigue?

Aprende a conectar un repositorio de GitLab Enterprise Edition.