Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Connettiti a un host GitLab Enterprise Edition

Questa pagina spiega come connettere l'host GitLab Enterprise Edition a Cloud Build.

Prima di iniziare

Abilita le API Cloud Build e Secret Manager.
Ruoli richiesti per abilitare le API
Per abilitare le API, devi disporre dell'autorizzazione serviceusage.services.enable. Se hai creato il progetto, probabilmente hai già questa autorizzazione tramite il ruolo Proprietario (roles/owner). In caso contrario, puoi ottenere questa autorizzazione tramite il ruolo Amministratore utilizzo servizi (roles/serviceusage.serviceUsageAdmin). Scopri come concedere i ruoli.
Abilita le API

Requisiti dell'host

Se non hai installato un'istanza del server GitLab Enterprise Edition, consulta la guida all'installazione di GitLab Enterprise Edition per le istruzioni.

Quando segui le istruzioni per installare un'istanza del server GitLab Enterprise Edition, tieni presente quanto segue:
- Devi configurare l'host per gestire il protocollo HTTPS. Gli host configurati con il protocollo HTTP non sono supportati.
- Devi configurare l'host con lo stesso URL utilizzato per raggiungere il tuo host da Google Cloud. Per saperne di più, consulta la documentazione di GitLab per configurare l'URL esterno.

Autorizzazioni IAM obbligatorie

Per connettere l'host GitLab Enterprise Edition, concedi il ruolo Amministratore connessione Cloud Build (roles/cloudbuild.connectionAdmin) al tuo account utente.

Per aggiungere i ruoli richiesti al tuo account utente, consulta Configurare l'accesso alle risorse Cloud Build. Per saperne di più sui ruoli IAM associati a Cloud Build, consulta Ruoli e autorizzazioni IAM.

Se la tua istanza GitLab Enterprise Edition è ospitata in una rete privata, consulta Creare repository da GitLab Enterprise Edition in una rete privata per scoprire di più sui ruoli IAM aggiuntivi richiesti prima della connessione host.

Connettersi a un host GitLab Enterprise Edition

Prima di creare una connessione host per l'istanza GitLab Enterprise Edition, devi creare token di accesso personali in GitLab Enterprise Edition completando i seguenti passaggi:

Accedi all'istanza GitLab Enterprise Edition.
Nella pagina GitLab Enterprise Edition della tua istanza, fai clic sul tuo avatar nell'angolo in alto a destra.
Fai clic su Modifica profilo.
Nella barra laterale a sinistra, seleziona Token di accesso.

Viene visualizzata la pagina Token di accesso personali.
Crea un token di accesso con l'ambito api da utilizzare per connettere e disconnettere i repository.
Crea un token di accesso con l'ambito read_api per assicurarti che i repository Cloud Build possano accedere al codice sorgente nei repository.

Nota: oltre ai token di accesso personali, puoi utilizzare anche i token di accesso al progetto. Se la tua versione di GitLab è 14.2 o successive, puoi utilizzare anche i token di accesso al gruppo. Se utilizzi token di accesso al progetto o al gruppo, seleziona il ruolo Maintainer per garantire una connessione riuscita.

Console

Per connettere l'host GitLab Enterprise Edition a Cloud Build:

Apri la pagina Repository nella Google Cloud console.

Apri la pagina Repository

Viene visualizzata la pagina Repository.
Nella parte superiore della pagina, seleziona la scheda 2ª generazione.
Nel selettore del progetto nella barra in alto, seleziona il tuo Google Cloud progetto.
Fai clic su Crea connessione host per connettere un nuovo host a Cloud Build.
Nel riquadro a sinistra, seleziona GitLab come provider di origine.
Nella sezione Configura connessione, inserisci le seguenti informazioni:
- Regione: seleziona una regione per la connessione.
  
  Nota: devi specificare una regione. La connessione non può esistere a livello globale.
- Nome: inserisci un nome per la connessione.
Nella sezione Dettagli host, seleziona o inserisci le seguenti informazioni:
- Host GitLab: seleziona GitLab Enterprise Edition autogestito.
- URL host: inserisci l'URL host per la connessione. Ad esempio, https://my-gle-server.net.
(Facoltativo) Se vuoi gestire le chiavi di crittografia utilizzate per criptare i token di accesso per i repository GitLab Enterprise Edition, vai alla sezione Crittografia e scegli una chiave Cloud Key Management Service. Per saperne di più, consulta Abilitare le chiavi di crittografia gestite dal cliente per Secret Manager.
Nella sezione Networking, in Tipo di connessione, seleziona una delle seguenti opzioni:
- Internet pubblico: seleziona questa opzione se la tua istanza è accessibile tramite internet pubblico.
- Rete privata: seleziona questa opzione se la tua istanza è ospitata su una rete privata. Quindi, configura quanto segue:
  1. Certificato CA: fai clic su Sfoglia per caricare il certificato autofirmato.
    
    Nota: la dimensione del certificato non deve superare i 10 kB e deve essere in formato PEM (.pem, .cer, o .crt). Se questa sezione viene lasciata vuota, verrà utilizzato un insieme predefinito di certificati al suo posto.
  2. In Servizio Service Directory, seleziona la località per il servizio:
    - Nel progetto CURRENT_PROJECT
    - In un altro progetto
    - Inserisci manualmente
  3. Inserisci le seguenti informazioni:
    - Progetto: se hai selezionato In un altro progetto o Inserisci manualmente, inserisci o seleziona l'ID progetto Google Cloud dal menu a discesa.
    - Regione: questo campo preselezione la regione della connessione. La regione specificata per il servizio deve corrispondere alla regione associata alla connessione.
    - Spazio dei nomi: seleziona lo spazio dei nomi del servizio.
    - Servizio: seleziona il nome del servizio nello spazio dei nomi.
Nella sezione Token di accesso personali, inserisci le seguenti informazioni:
- Token di accesso API: inserisci il token con accesso all'ambito api. Questo token viene utilizzato per connettere e disconnettere i repository.
- Token di accesso alle API in lettura: inserisci il token con accesso all'ambito read_api. I trigger di Cloud Build utilizzano questo token per accedere al codice sorgente nei repository.
Fai clic su Connetti.

Dopo aver fatto clic sul pulsante Connetti, i token di accesso personali vengono archiviati in modo sicuro in Secret Manager. Dopo la connessione host, Cloud Build crea anche un secret webhook per tuo conto. Puoi visualizzare e gestire i secret nella pagina Secret Manager. Puoi visualizzare e gestire i tuoi secret nella pagina Secret Manager.

gcloud

Prima di connettere l'host GitLab Enterprise Edition a Cloud Build, completa i seguenti passaggi per archiviare le credenziali:

Archivia il token in Secret Manager.

Crea un secret webhook in Secret Manager eseguendo il seguente comando:

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

Se archivi i secret in un Google Cloud progetto diverso da quello che intendi utilizzare per creare una connessione host, inserisci il seguente comando per concedere al tuo progetto l'accesso all'agente di servizio 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"

Dove:

PROJECT_ID è l'ID Google Cloud progetto.

Ora puoi procedere per connettere l'host GitLab Enterprise Edition a Cloud Build.

Completa i seguenti passaggi:

Inserisci il seguente comando per creare una connessione 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
```
Dove:
- CONNECTION_NAME è un nome per la connessione in Cloud Build.
- HOST_URI è l'URI dell'istanza GitLab Enterprise Edition. Ad esempio, https://my-gle-server.net.
- PROJECT_ID è l'ID Google Cloud progetto.
- REGION è la regione per la connessione.
- API_TOKEN è il nome del token con ambito api.
- READ_TOKEN è il nome del token con ambito read_api.
- SECRET_VERSION è la versione del secret.
- WEBHOOK_SECRET è il secret webhook.

Hai creato una connessione GitLab Enterprise Edition.

Terraform

Puoi connettere l'host GitLab Enterprise Edition a Cloud Build utilizzando Terraform. Scopri di più su Terraform Google Cloud.

Nell'esempio seguente, lo snippet di codice esegue le seguenti operazioni:

Configura il provider Terraform per Google Cloud risorse
Crea un secret per archiviare il token di accesso personale di GitLab Enterprise Edition
Concede le autorizzazioni necessarie all'agente di servizio Cloud Build per accedere ai secret

Crea una connessione GitLab Enterprise Edition

// Configure the Terraform Google provider
terraform {
  required_providers {
    google = {}
  }
}

// Create secrets and grant permissions to the Cloud Build service agent
resource "google_secret_manager_secret" "api-pat-secret" {
    project = "PROJECT_ID"
    secret_id = "GITLAB_PAT_API"

    replication {
        auto {}
     }
 }

 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 {
         auto {}
     }
}

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

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

    replication {
        auto {}
    }
}

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.api-pat-secret.project
  secret_id = google_secret_manager_secret.api-pat-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.read-pat-secret.project
  secret_id = google_secret_manager_secret.read-pat-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 {
        host_uri = "URI"
        authorizer_credential {
            user_token_secret_version = google_secret_manager_secret_version.api-pat-secret-version.id
        }
        read_authorizer_credential {
             user_token_secret_version = google_secret_manager_secret_version.read-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
    ]
}

Sostituisci quanto segue:

PROJECT_ID: l' Google Cloud ID progetto.
GITLAB_PAT_API: il token di accesso personale con accesso api.
GITLAB_API_TOKEN: il token di accesso personale.
GITLAB_PAT_READ: il token di accesso personale con accesso read_api.
WEBHOOK_SECRET: il nome del secret contenente il valore del secret webhook.
WEBHOOK_SECRET_VALUE: il valore del secret webhook.
PROJECT_NUMBER: il tuo Google Cloud numero di progetto. Puoi trovare il numero di progetto nella pagina di benvenuto della Google Cloud console o eseguendo il seguente comando:
```
gcloud projects describe PROJECT_ID --format='value(projectNumber)'
```
REGION: la regione per la connessione.
CONNECTION_NAME: un nome per la connessione host GitLab Enterprise Edition in Cloud Build.
URI: l'URI della connessione, ad esempio https://my-gitlab-enterprise-server.net.

Hai creato una connessione GitLab Enterprise Edition.

Ruotare i token di accesso GitLab Enterprise Edition vecchi o scaduti

Ruota i token di accesso in modo che la connessione host Cloud Build possa mantenere la connessione al repository GitLab Enterprise Edition. Se il token di accesso GitLab Enterprise Edition scade, la connessione host Cloud Build viene disconnessa dal repository GitLab Enterprise Edition. In questo caso, non puoi disattivare la connessione o collegare un repository finché non ruoti il token scaduto. Inoltre, si verificano errori nelle seguenti circostanze:

La pagina Dettagli connessione della connessione mostra un messaggio di errore che indica Connection is disconnected due to an invalid or expired access token (La connessione è disconnessa a causa di un token di accesso non valido o scaduto).
Se provi a collegare un repository a una connessione con un token scaduto, viene visualizzato il messaggio Token di accesso non valido. Se fai clic su Visualizza connessione , viene visualizzata la pagina Dettagli connessione per la connessione con il token scaduto.

Cloud Build ti consente di ruotare i token di accesso inserendo nuovi valori dei token e salvandoli in Secret Manager nell'ultima versione del secret per questi token. Per ruotare i token di accesso:

Ruota ogni token di accesso in GitLab Enterprise Edition:
1. Vai al repository GitLab Enterprise Edition connesso alla connessione host Cloud Build.
2. Segui le istruzioni nella documentazione di GitLab per ruotare un token di accesso. Quando ruoti un token, GitLab Enterprise Edition crea un nuovo token con nuove credenziali e invalida la versione precedente del token. Il token ruotato ha le stesse autorizzazioni e lo stesso ambito del token originale.
3. Copia gli ID dei token ruotati.
Aggiorna il token di accesso in Cloud Build:
1. Vai alla pagina Dettagli connessione per la connessione.
2. Seleziona Aggiorna token di accesso.
3. Nel menu Rotazione token, inserisci i nuovi token nei campi Token di accesso API e Token di accesso in lettura.
4. (Facoltativo) Se vuoi che la connessione utilizzi sempre l'ultima versione del secret per i token, seleziona Aggiorna connessione per utilizzare sempre l'ultima versione. Se lasci questa opzione deselezionata, potrebbe essere utile se la connessione utilizza un numero di versione del secret specifico.
5. Seleziona Aggiorna per salvare le modifiche.
  
  Cloud Build salva i nuovi token di accesso come ultima versione del secret in Secret Manager.

Per saperne di più, consulta Scadenza del token di accesso nella documentazione di GitLab Enterprise Edition.

Passaggi successivi

Scopri come connettere un repository GitLab Enterprise Edition.
Scopri come creare ed eseguire il deployment dei carichi di lavoro Google Cloud utilizzando i componenti CI/CD gestiti da Google nella pipeline GitLab. Consulta GitLab Google Cloud.