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

Importare componenti

App Design Center supporta diversi Google Cloud prodotti che puoi aggiungere come componenti alla tua applicazione. Per utilizzare la tua versione di questi componenti o aggiungere altri componenti, importa i moduli Terraform in App Design Center.

I moduli Terraform sono configurazioni riutilizzabili per i Google Cloud prodotti. L'importazione dei moduli Terraform ti consente di:

Accelerare e controllare lo sviluppo delle applicazioni.
Riutilizzare le decisioni di progettazione esistenti in App Design Center.
Aiutare gli sviluppatori di applicazioni a rispettare le norme di progettazione stabilite.

Quando importi un modulo Terraform, App Design Center crea un template di componente corrispondente nel catalogo del tuo spazio. Puoi quindi utilizzare il template come componente nella progettazione del template dell'applicazione.

Per scoprire di più su Terraform su Google Cloud, consulta le seguenti risorse:

Prima di iniziare

Per eseguire le attività descritte in questo documento, chiedi all'amministratore di concederti i ruoli necessari nella cartella abilitata per le app o nel progetto di gestione, come indicato nella tabella seguente:

Attività	Ruoli obbligatori
Importare i moduli Terraform come componenti personalizzati	App Design Center Admin (`roles/designcenter.admin`) o App Design Center User (`roles/designcenter.user`)

Per saperne di più sui ruoli, consulta Controllo dell'accesso con IAM.

Configurare e importare i moduli

Completa i seguenti passaggi per connetterti a GitHub, creare un file di metadati e importare un modulo Terraform.

Connettersi al repository utilizzando Developer Connect

Crea una connessione Developer Connect al repository GitHub in cui memorizzi i Google Cloud moduli Terraform. Utilizzerai questa connessione durante l'importazione.

Crea una connessione Developer Connect.

Per le istruzioni, vedi Connettersi a GitHub.
Crea un link al repository Developer Connect.

Per le istruzioni, vedi Aggiungere link ai repository alle connessenti esistenti.

(Facoltativo) Preparare i metadati del modulo Terraform

Quando importi il modulo Terraform, puoi fornire i tuoi metadati o lasciare che App Design Center crei un file di metadati per te.

Ad esempio, di seguito è riportato un file metadata.yaml che potresti creare per un account di servizio:

  spec:
    info:
      actuationTool:
        flavor: Terraform
        version: ">= 1.3"
    interfaces: # Optional
      variables:
        - name: service_account
          connections:
            - source:
                source: github.com/terraform-google/terraform-google-service-accounts
                version: ">= 4.4"
              spec:
                outputExpr: email
    requirements:
      roles: # Optional after IAM integrations
        - level: Project
          roles:
            - roles/iam.serviceAccountUser
            - roles/iap.admin
            - roles/run.admin
            - roles/iam.serviceAccountAdmin
      providerVersions:
        - source: hashicorp/google
          version: ">= 6, < 7"
        - source: hashicorp/google-beta
          version: ">= 6, < 7"
    ui: # Optional
      input:
        variables:
          ca_root_module:
            name: ca_root_module
            title: CA Root Module
          service_account:
            name: service_account
            title: Service Account

Importare dal repository

Puoi creare un componente App Design Center importando un modulo Terraform basato su un singolo Google Cloud prodotto. Se apporti modifiche al modulo Terraform nel repository, ripeti questi passaggi per importare le modifiche.

Per importare il modulo Terraform:

Identifica il catalogo in cui vuoi creare il componente.
```
  gcloud design-center spaces catalogs list \
  --project=PROJECT \
  --location=LOCATION \
  --space=SPACE
```
Sostituisci quanto segue:
- PROJECT: l'ID del progetto di gestione .
- LOCATION: ID località.
- SPACE: l'ID dello spazio.
Per saperne di più, consulta gcloud design-center spaces catalogs list.
Crea un template di catalogo nel catalogo privato del tuo spazio.
```
  gcloud design-center spaces catalogs templates create COMPONENT_TEMPLATE \
  --project=PROJECT \
  --catalog=CATALOG \
  --location=LOCATION \
  --space=SPACE \
  --template-category=component-template
```
Sostituisci quanto segue:
- COMPONENT_TEMPLATE: l'ID del template per il template di componente che vuoi creare.
- PROJECT: l'ID del progetto di gestione .
- CATALOG: l'ID del catalogo.
- LOCATION: ID località.
- SPACE: l'ID dello spazio.
Per saperne di più, consulta gcloud design-center spaces catalogs templates create.
Crea una revisione del template di catalogo basata sul modulo Terraform nel repository.
```
  gcloud design-center spaces catalogs templates revisions create REVISION \
  --project=PROJECT \
  --catalog=CATALOG \
  --location=LOCATION \
  --space=SPACE \
  --template=COMPONENT_TEMPLATE \
  --developer-connect-repo=DEVELOPER_CONNECT_REPO \
  --developer-connect-repo-ref=DEVELOPER_CONNECT_REPO_REF \
  --developer-connect-repo-dir=DEVELOPER_CONNECT_REPO_DIR \
  --metadata=METADATA
```
Sostituisci quanto segue:
- REVISION: l'ID della revisione che vuoi creare.
- PROJECT: l'ID del progetto di gestione .
- CATALOG: l'ID del catalogo.
- LOCATION: ID località.
- SPACE: l'ID dello spazio.
- COMPONENT_TEMPLATE: l'ID del template che hai creato nel passaggio precedente.
- DEVELOPER_CONNECT_REPO: il repository Developer Connect da utilizzare come origine. Ad esempio, projects/my-project/locations/us-central1/connections/my-connection/gitRepositoryLinks/my-repo.
- DEVELOPER_CONNECT_REPO_REF: il ramo o il tag Git nel repository. Ad esempio, refs/tags/v1.0.0 o refs/heads/main.
- DEVELOPER_CONNECT_REPO_DIR: la directory nel repository. Ad esempio, modules/my-product.
- Per specificare i metadati del modulo Terraform, procedi in uno dei seguenti modi:
  - Per utilizzare il tuo file di metadati, sostituisci METADATA con il tuo file metadata.yaml.
  - Per utilizzare automaticamente i file di metadati che si trovano nel repository, lascia il flag --metadata non specificato.
Per saperne di più, consulta gcloud design-center spaces catalogs templates revisions create.
Condividi il catalogo con altri spazi.
```
  gcloud design-center spaces catalogs shares create SHARE \
  --project=PROJECT \
  --catalog=CATALOG \
  --location=LOCATION \
  --space=SPACE \
  --destination-space=DESTINATION_SPACE
```
Sostituisci quanto segue:
- SHARE: l'ID della condivisione che vuoi creare.
- PROJECT: l'ID del progetto di gestione .
- CATALOG: l'ID del catalogo.
- LOCATION: ID località.
- SPACE: l'ID dello spazio.
- DESTINATION_SPACE: l'ID dello spazio di destinazione.
Per saperne di più, consulta gcloud design-center spaces catalogs shares create.

Creare un template di applicazione utilizzando i componenti importati

Crea un template di applicazione utilizzando i componenti importati e quelli forniti da Google.

Crea un nuovo template di applicazione.
```
  gcloud design-center spaces application-templates create APPLICATION_TEMPLATE \
  --project=PROJECT \
  --location=LOCATION \
  --space=SPACE
```
Sostituisci quanto segue:
- APPLICATION_TEMPLATE: l'ID del template per il template di applicazione che vuoi creare.
- PROJECT: l'ID del progetto di gestione .
- LOCATION: ID località.
- SPACE: l'ID dello spazio.
Per saperne di più, consulta gcloud design-center spaces application-templates create.
Identifica gli URI di revisione del template per i componenti che vuoi aggiungere al template.
```
  gcloud design-center spaces shared-templates list \
  --project=PROJECT \
  --location=LOCATION \
  --space=SPACE \
  --uri
```
Sostituisci quanto segue:
- PROJECT: l'ID del progetto di gestione .
- LOCATION: ID località.
- SPACE: l'ID dello spazio.
Per saperne di più, consulta gcloud design-center spaces shared-templates list.
Aggiungi un componente al template dell'applicazione.
```
  gcloud design-center spaces application-templates components create COMPONENT \
  --project=PROJECT \
  --location=LOCATION \
  --space=SPACE \
  --application-template=APPLICATION_TEMPLATE \
  --shared-template-revision-uri=SHARED_TEMPLATE_URI
```
Sostituisci quanto segue:
- COMPONENT: l'ID del componente che vuoi aggiungere al template.
- PROJECT: l'ID del progetto di gestione .
- LOCATION: ID località.
- SPACE: l'ID dello spazio.
- APPLICATION_TEMPLATE: l'ID del template per il template di applicazione a cui stai aggiungendo il componente.
- SHARED_TEMPLATE_URI: l'URI del modello condiviso del componente. Ad esempio, projects/my-project/locations/us-central1/spaces/my-space/sharedTemplates/my-shared-template/revisions/rev1.
Per saperne di più, consulta gcloud design-center spaces application-templates components create.
Aggiungi un secondo componente al template.
```
  gcloud design-center spaces application-templates components create COMPONENT_2 \
  --project=PROJECT \
  --location=LOCATION \
  --space=SPACE \
  --application-template=APPLICATION_TEMPLATE \
  --shared-template-revision-uri=SHARED_TEMPLATE_URI_2
```
Sostituisci quanto segue:
- COMPONENT_2: l'ID del componente per il secondo componente che vuoi aggiungere al template.
- PROJECT: l'ID del progetto di gestione .
- LOCATION: ID località.
- SPACE: l'ID dello spazio.
- APPLICATION_TEMPLATE: l'ID del template per il template di applicazione a cui stai aggiungendo il componente.
- SHARED_TEMPLATE_URI_2: l'URI del template condiviso del secondo componente. Ad esempio, projects/my-project/locations/us-central1/spaces/my-space/sharedTemplates/my-shared-template/revisions/rev1.
Per saperne di più, consulta gcloud design-center spaces application-templates components create.
Crea una connessione tra i due componenti.
```
  gcloud design-center spaces application-templates components connections create CONNECTION \
  --project=PROJECT \
  --location=LOCATION \
  --space=SPACE \
  --application-template=APPLICATION_TEMPLATE \
  --component=COMPONENT \
  --destination-component-uri=SHARED_TEMPLATE_URI_2
```
Sostituisci quanto segue:
- CONNECTION: l'ID della connessione che vuoi aggiungere al template.
- PROJECT: l'ID del progetto di gestione .
- LOCATION: ID località.
- SPACE: l'ID dello spazio.
- APPLICATION_TEMPLATE: l'ID del template per il template di applicazione a cui stai aggiungendo il componente.
- SHARED_TEMPLATE_URI_2: l'URI del template condiviso del secondo componente. Ad esempio, projects/my-project/locations/us-central1/spaces/my-space/sharedTemplates/my-shared-template/revisions/rev1.
Per saperne di più, consulta gcloud design-center spaces application-templates components connections create.

Passaggi successivi

Prima di eseguire il deployment, crea un'applicazione.
Esegui il deployment delle applicazioni.
Esporta il codice Terraform.