Esegui il provisioning di un'organizzazione a pagamento con il peering VPC

Esegui il provisioning di un'organizzazione a pagamento con il peering VPC

Questa pagina si applica a Apigee, ma non a Apigee ibrido.

Visualizza documentazione di Apigee Edge.

Questo documento descrive come installare e configurare Apigee dalla riga di comando con il peering VPC. Questi passaggi si applicano ai modelli di prezzi sia in abbonamento sia a consumo per le organizzazioni a pagamento con o senza residenza dei dati abilitata.

Riepilogo dei passaggi

I passaggi per il provisioning sono i seguenti:

Passaggio 1: definizione delle variabili di ambiente

Configura gcloud e definisci le variabili di ambiente da utilizzare nei passaggi successivi:

  1. Assicurati di aver soddisfatto i requisiti di configurazione elencati in Prima di iniziare.
  2. Devi avere installato Cloud SDK. Se è necessario installarlo, consulta Installazione di Cloud SDK.
  3. Inizializza Cloud SDK, come descritto in Inizializzare gcloud CLI, oppure assicurati che in altro modo il progetto Google Cloud che hai creato in Prerequisiti è il progetto predefinito gcloud.
  4. Definisci le seguenti variabili di ambiente nel terminale dei comandi. Seleziona la scheda corrispondente al tipo di organizzazione di cui hai bisogno: Nessuna residenza dei dati o con Residenza dei dati:

    Nessuna residenza dei dati

    AUTH="$(gcloud auth print-access-token)"
PROJECT_ID="YOUR_PROJECT_ID"
PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
RUNTIME_LOCATION="YOUR_RUNTIME_LOCATION"
ANALYTICS_REGION="YOUR_ANALYTICS_REGION"
BILLING_TYPE="YOUR_BILLING_TYPE"

    Dove:

    • AUTH definisce l'intestazione Authentication con un token di accesso. Utilizzerai questo header quando chiami le API Apigee. Tieni presente che il token scade dopo un determinato periodo di tempo e quando accade, è sufficiente rigenerarlo utilizzando lo stesso comando. Per ulteriori informazioni, consulta la pagina di riferimento per get_print-access-token.
    • PROJECT_ID è l'ID progetto Cloud che hai creato nell'ambito dei prerequisiti.
    • PROJECT_NUMBER è il numero del progetto Cloud che hai creato nell'ambito dei prerequisiti.

    • RUNTIME_LOCATION è la posizione fisica in cui si trova l'istanza Apigee che creerai in seguito. Per un elenco delle località di runtime disponibili, vedi Località Apigee.

    • ANALYTICS_REGION è la posizione fisica in cui verranno archiviati i dati di analisi di Apigee. Per un elenco delle regioni di Apigee API Analytics disponibili, consulta Località Apigee.

      Sia RUNTIME_LOCATION che ANALYTICS_REGION possono essere la stessa regione, ma non è obbligatorio.

    • BILLING_TYPE è il tipo di fatturazione per l'organizzazione che crei. I valori validi sono:

    Residenza dei dati

    AUTH="$(gcloud auth print-access-token)"
PROJECT_ID="YOUR_PROJECT_ID"
PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
RUNTIME_LOCATION="YOUR_RUNTIME_LOCATION"
CONTROL_PLANE_LOCATION="YOUR_CONTROL_PLANE_LOCATION"
CONSUMER_DATA_REGION="YOUR_CONSUMER_DATA_REGION"
BILLING_TYPE="YOUR_BILLING_TYPE"

    Dove:

    • AUTH definisce l'intestazione Authentication con un token di connessione. Utilizzerai questo header quando chiami le API Apigee. Tieni presente che il token scade dopo un determinato periodo di tempo e quando accade, è sufficiente rigenerarlo utilizzando lo stesso comando. Per ulteriori informazioni, consulta la pagina di riferimento per get_print-access-token.
    • PROJECT_ID è l'ID del progetto Cloud che hai creato nell'ambito della Prerequisiti.
    • PROJECT_NUMBER è il numero del progetto Cloud che hai creato come parte dei Prerequisiti.

    • RUNTIME_LOCATION è la posizione fisica in cui si trova l'istanza Apigee che creerai in seguito. Per un elenco delle località di runtime disponibili, vedi Località Apigee.

      di Gemini Advanced. La località di runtime deve essere all'interno dalla posizione del piano di controllo.
    • CONTROL_PLANE_LOCATION è la località fisica in cui verranno archiviati i dati del piano di controllo Apigee. Per un elenco delle posizioni dei piani di controllo disponibili, vedi Località Apigee.
    • CONSUMER_DATA_REGION è una sottoregione della regione del piano di controllo. Devi specificare sia CONTROL_PLANE_LOCATION che CONSUMER_DATA_REGION. Per un elenco delle regioni di dati dei consumatori disponibili, consulta Località Apigee.

    • BILLING_TYPE è il tipo di fatturazione per l'organizzazione che crei. I valori validi sono:

      • PAYG per le organizzazioni che prevedono il Pay-as-you-go.
      • SUBSCRIPTION per le organizzazioni che utilizzano gli abbonamenti.

  5. (Facoltativo) Controlla il tuo lavoro eseguendo l'echo dei valori appena impostati. Tieni presente che quando vuoi utilizzare una variabile nei comandi, devi precedere il nome della variabile con il segno di dollaro ($).

    Nessuna residenza dei dati

    echo $AUTH
echo $PROJECT_ID
echo $PROJECT_NUMBER
echo $RUNTIME_LOCATION
echo $ANALYTICS_REGION
echo $BILLING_TYPE

    Le risposte ai tuoi comandi echo dovrebbero avere il seguente aspetto:

    YOUR_TOKEN
my-cloud-project
1234567890
us-west1
us-west1
SUBSCRIPTION

    Residenza dei dati

    echo $AUTH
echo $PROJECT_ID
echo $PROJECT_NUMBER
echo $RUNTIME_LOCATION
echo $CONTROL_PLANE_LOCATION
echo $CONSUMER_DATA_REGION
echo $BILLING_TYPE

    Le risposte ai comandi echo dovrebbero essere simili alle seguenti:

    YOUR_TOKEN
my-cloud-project
1234567890
us-west1
us
us-west1
SUBSCRIPTION

Passaggio 2: attivazione delle API

  1. Apigee richiede l'abilitazione di diverse API Google Cloud. Per abilitarle, esegui questo comando services enable :

    gcloud services enable apigee.googleapis.com \
    servicenetworking.googleapis.com \
    compute.googleapis.com \
    cloudkms.googleapis.com --project=$PROJECT_ID

  2. (Facoltativo) Per controllare il tuo lavoro, utilizza il comando services list per mostrare tutte le API abilitate:

    gcloud services list

    La risposta mostra tutti i servizi abilitati, incluse le API che hai appena attivato.

Passaggio 3: crea l'identità del servizio Apigee

  1. Crea la piattaforma Apigee Service Identity (Identità servizio):

    gcloud beta services identity create --service=apigee.googleapis.com \
  --project=$PROJECT_ID

  2. Verifica che l'agente sia stato creato correttamente. La risposta dovrebbe mostrare il nome l'agente nel seguente formato: service-PROJECT_NUMBER@gcp-sa-apigee.iam.gserviceaccount.com. ad esempio: 

    Service identity created: service-1234567890@gcp-sa-apigee.iam.gserviceaccount.com

Passaggio 4: configurazione del networking di servizi

In questo passaggio assegnerai una coppia di intervalli di indirizzi IP (un intervallo CIDR /22 e /28) ad Apigee e il peering VPC tra la tua rete e la rete Apigee. Ogni istanza Apigee richiede un intervallo CIDR non sovrapposto di /22 e /28. Il piano di runtime Apigee sono assegnati indirizzi IP interni a questo intervallo CIDR. Di conseguenza, è importante che l'intervallo sia riservato ad Apigee e non utilizzato da altre applicazioni nella rete VPC. Per ulteriori informazioni e considerazioni importanti, consulta Informazioni sugli intervalli di peering.

Tieni presente che stai creando un intervallo IP di rete sufficiente per un'istanza Apigee. Se prevedi di creare altre istanze Apigee, devi ripetere questo passaggio per ciascuna. Gli intervalli e non possono essere condivisi tra le istanze. Consulta anche Espandere Apigee in più regioni.

  1. Crea queste variabili di ambiente: 
    RANGE_NAME=YOUR_RANGE_NAME
NETWORK_NAME=YOUR_NETWORK_NAME

    Dove:

    • RANGE_NAME è il nome dell'intervallo di indirizzi IP che stai creando. Puoi assegnare all'intervallo il nome che preferisci. Ad esempio: google-svcs
    • NETWORK_NAME è il nome della risorsa di rete in cui gli indirizzi deve essere prenotato.

      Google crea una rete predefinita (denominata default) per ogni nuovo progetto, che puoi utilizzare. Tuttavia, Google sconsiglia di utilizzare la rete predefinita per altri scopi oltre ai test.

  2. Crea un intervallo IP di rete con una lunghezza CIDR di /22: 
    gcloud compute addresses create $RANGE_NAME \
  --global \
  --prefix-length=22 \
  --description="Peering range for Apigee services" \
  --network=$NETWORK_NAME \
  --purpose=VPC_PEERING \
  --addresses=OPTIONAL_ADDRESSES \
  --project=$PROJECT_ID

    Dove --addresses ti consente di specificare facoltativamente di indirizzi IP esterni. Ad esempio, per allocare il blocco CIDR 192.168.0.0/22, specifica 192.168.0.0 per l'indirizzo e 22 per la lunghezza del prefisso. Vedi anche Creazione di un'allocazione IP.

    Se non fornisci il parametro --addresses, gcloud seleziona un intervallo di indirizzi disponibile per te.

    Se l'operazione riesce, gcloud risponde con quanto segue:

    Created [https://www.googleapis.com/compute/v1/projects/PROJECT_NAME/global/addresses/google-svcs].

    Dopo aver creato un intervallo di indirizzi IP, questi vengono associati al progetto finché non li rilasci.

  3. Verifica che l'intervallo IP della rete sia stato creato con una lunghezza CIDR di /22: 
    gcloud compute addresses list --global --project=$PROJECT_ID
gcloud compute addresses describe $RANGE_NAME --global --project=$PROJECT_ID
  4. Crea un intervallo IP di rete con lunghezza CIDR di /28. Questo intervallo è obbligatorio e viene utilizzato da Apigee per la risoluzione dei problemi e non può essere personalizzato o modificato. 
    gcloud compute addresses create google-managed-services-support-1 \
  --global \
  --prefix-length=28 \
  --description="Peering range for supporting Apigee services" \
  --network=$NETWORK_NAME \
  --purpose=VPC_PEERING \
  --addresses=OPTIONAL_ADDRESSES \
  --project=$PROJECT_ID

    Dove --addresses ti consente di specificare facoltativamente di indirizzi IP esterni. Ad esempio, per allocare il blocco CIDR 192.168.0.0/28, specifica 192.168.0.0 per l'indirizzo e 28 per la lunghezza del prefisso. Vedi anche Creazione di un'allocazione IP.

    Se non fornisci il parametro --addresses, gcloud seleziona un intervallo di indirizzi disponibile per te.

  5. Verifica che l'intervallo IP della rete sia stato creato con una lunghezza CIDR di /28: 
    gcloud compute addresses list --global --project=$PROJECT_ID
gcloud compute addresses describe google-managed-services-support-1 --global \
  --project=$PROJECT_ID
  6. Connetti i servizi alla rete utilizzando il seguente comando: 
    gcloud services vpc-peerings connect \
  --service=servicenetworking.googleapis.com \
  --network=$NETWORK_NAME \
  --ranges=$RANGE_NAME,google-managed-services-support-1 \
  --project=$PROJECT_ID

    L'operazione potrebbe richiedere diversi minuti. Se l'operazione riesce, gcloud risponde con il codice seguente, dove OPERATION_ID è l'UUID dell'LRO.

    Operation "operations/OPERATION_ID" finished successfully.

    7. Apigee crea una connessione tra la tua rete e i servizi Google. in particolare, Apigee connette il progetto all'API Service Networking tramite peering VPC. Apigee associato anche gli indirizzi IP al tuo progetto.

  7. Dopo alcuni minuti, verifica se il peering VPC è riuscito: 
    gcloud services vpc-peerings list \
  --network=$NETWORK_NAME \
  --service=servicenetworking.googleapis.com \
  --project=$PROJECT_ID

Passaggio 5: crea un'organizzazione

Prima di poter creare un'organizzazione, devi creare un database di runtime il keyring e la chiave di crittografia (vedi il passaggio 1); inoltre, se utilizzano residenza dei dati, keyring e chiavi di crittografia del piano di controllo (vedi il passaggio 2). Queste chiavi Cloud KMS criptano i dati archiviati e replicati nelle posizioni del piano di controllo e di runtime. Apigee utilizza queste entità per crittografare i dati delle applicazioni come KVM, cache e client secret, quindi archiviato nel database. Per ulteriori informazioni, vedi Informazioni sulle chiavi di crittografia Apigee.

  1. Creare un keyring e una chiave di crittografia del database di runtime.

    1. Definisci una variabile di ambiente per la posizione dell'anello e della chiave di crittografia del database di runtime. In questo modo puoi garantire la coerenza durante la creazione e seguire più facilmente la documentazione.

      Il valore è la posizione fisica in cui sono archiviati il tuo anello di chiavi di crittografia del database di runtime e la chiave.

      Regione singola

      Configurazioni per una singola regione (in cui hai una sola istanza in una regione): scegli tra le località regionali KMS supportate.

      Ad esempio:

      RUNTIMEDBKEY_LOCATION="us-west1"

      Il valore può essere uguale a $RUNTIME_LOCATION (anche una regione), ma non deve esserlo. Tuttavia, potrebbero esserci vantaggi in termini di prestazioni se in modo analogo.

      Più regioni

      Configurazioni multi-regione: scegli tra le località multiregionali supportate (ad es. us o europe) o le località a due regioni.

      Ad esempio:

      RUNTIMEDBKEY_LOCATION="us"

      Se hai una configurazione per più regioni negli Stati Uniti, ti consigliamo di utilizzare us per la tua località, se possibile. Altrimenti, usa nam4.

    2. Definisci le variabili di ambiente per i keyring e i nomi delle chiavi del database.

      Il nome del portachiavi deve essere univoco per la tua organizzazione. Se crei un seconda o successiva, il nome non può essere uguale a quello degli altri keyring i nomi degli utenti.

      RUNTIMEDB_KEY_RING_NAME=YOUR_DB_KEY_RING_NAME
RUNTIMEDB_KEY_NAME=YOUR_DB_KEY_NAME
    3. (Facoltativo) Controlla il tuo lavoro eseguendo l'echo dei valori appena impostati. Ricorda che quando vuoi utilizzare una variabile nei comandi, devi precedere il nome della variabile con il segno di dollaro ($). 
      echo $RUNTIMEDBKEY_LOCATION
echo $RUNTIMEDB_KEY_RING_NAME
echo $RUNTIMEDB_KEY_NAME
    4. Crea un nuovo keyring: 
      gcloud kms keyrings create $RUNTIMEDB_KEY_RING_NAME \
  --location $RUNTIMEDBKEY_LOCATION --project $PROJECT_ID

      La posizione della chiave di crittografia del database di runtime Apigee supporta tutte le risorse Cloud KMS località che supportano Cloud HSM e Cloud EKM.

    5. Crea una chiave:

      gcloud kms keys create $RUNTIMEDB_KEY_NAME \
  --keyring $RUNTIMEDB_KEY_RING_NAME \
  --location $RUNTIMEDBKEY_LOCATION \
  --purpose "encryption" \
  --project $PROJECT_ID

      Questo comando crea la chiave e la aggiunge al keyring.

      Recupera l'ID chiave:

      gcloud kms keys list \
  --location=$RUNTIMEDBKEY_LOCATION \
  --keyring=$RUNTIMEDB_KEY_RING_NAME \
  --project=$PROJECT_ID

      L'ID chiave ha la seguente sintassi (simile a un percorso file):

      projects/PROJECT_ID/locations/RUNTIMEDBKEY_LOCATION/keyRings/RUNTIMEDB_KEY_RING_NAME/cryptoKeys/RUNTIMEDB_KEY_NAME

    6. Inserisci l'ID chiave in una variabile di ambiente. Utilizzerai questa variabile in un comando successivo:

      RUNTIMEDB_KEY_ID=YOUR_RUNTIMEDB_KEY_ID

    7. Concedi all'agente di servizio Apigee l'accesso per utilizzare la nuova chiave:

      gcloud kms keys add-iam-policy-binding $RUNTIMEDB_KEY_NAME \
  --location $RUNTIMEDBKEY_LOCATION \
  --keyring $RUNTIMEDB_KEY_RING_NAME \
  --member serviceAccount:service-$PROJECT_NUMBER@gcp-sa-apigee.iam.gserviceaccount.com \
  --role roles/cloudkms.cryptoKeyEncrypterDecrypter \
  --project $PROJECT_ID

      Questo comando associa la chiave all'agente di servizio Apigee.

      Una volta completata questa richiesta, gcloud risponde con qualcosa di simile a questo:

      Updated IAM policy for key [runtime].
bindings:
- members:
  - serviceAccount:service-1234567890@gcp-sa-apigee.iam.gserviceaccount.com
  role: roles/cloudkms.cryptoKeyEncrypterDecrypter
etag: BwWqgEuCuwk=
version: 1

      Se ricevi un errore simile al seguente:

      INVALID_ARGUMENT: Role roles/cloudkms.cryptokms.cryptoKeyEncrypterDecrypter is not supported for this resource.

      Assicurati di aver utilizzato il numero del progetto e non il nome del progetto nella l'indirizzo email dell'account di servizio.

  2. Se utilizzi la residenza dei dati, creare un keyring di crittografia del piano di controllo chiave. Se non utilizzi la residenza dei dati, vai al passaggio 3.

    3. Esegui i passaggi che seguono per creare un keyring e una chiave di crittografia del piano di controllo.

    1. Definisci una variabile di ambiente per la posizione del keyring e della chiave di crittografia del database del piano di controllo: 
      CONTROL_PLANE_LOCATION=YOUR_CONTROL_PLANE_LOCATION
CONSUMER_DATA_REGION=YOUR_CONSUMER_DATA_REGION

      Dove:

      • CONTROL_PLANE_LOCATION è la posizione fisica in cui verranno archiviati i dati del piano di controllo di Apigee. Per un elenco delle località del piano di controllo disponibili, consulta Località di Apigee.
      • CONSUMER_DATA_REGION è una sottoregione della regione del piano di controllo. Devi specificare sia CONTROL_PLANE_LOCATION sia CONSUMER_DATA_REGION. Per un elenco delle regioni di dati dei consumatori disponibili, consulta Località Apigee.

    2. Definisci le variabili di ambiente per i keyring e i nomi delle chiavi del database del piano di controllo.

      Il nome del portachiavi deve essere univoco per la tua organizzazione.

      CONTROL_PLANE_KEY_RING_NAME=YOUR_CONTROL_PLANE_KEY_RING_NAME
CONTROL_PLANE_KEY_NAME=YOUR_CONTROL_PLANE_KEY_NAME
CONSUMER_DATA_KEY_RING_NAME=YOUR_CONSUMER_DATA_KEY_RING_NAME
CONSUMER_DATA_KEY_NAME=YOUR_CONSUMER_DATA_REGION_KEY_NAME

      Dove:

      • CONTROL_PLANE_KEY_RING_NAME è il nome del keyring di crittografia del control plane che utilizzerai per identificarlo.
      • CONTROL_PLANE_KEY_NAME è il nome della chiave che utilizzerai per identificare la chiave di crittografia del piano di controllo.
      • CONSUMER_DATA_KEY_RING_NAME è il nome del keyring che utilizzerai per identificare il keyring di crittografia della regione di dati consumer.
      • CONSUMER_DATA_KEY_NAME è il nome della chiave che utilizzerai per identificare la chiave di crittografia della regione di dati consumer.
    3. Crea un nuovo keyring: 
      gcloud kms keyrings create $CONTROL_PLANE_KEY_RING_NAME \
  --location $CONTROL_PLANE_LOCATION \
  --project $PROJECT_ID
       
      gcloud kms keyrings create $CONSUMER_DATA_KEY_RING_NAME \
  --location $CONSUMER_DATA_REGION \
  --project $PROJECT_ID
    4. Crea una chiave: 
      gcloud kms keys create $CONTROL_PLANE_KEY_NAME \
  --keyring $CONTROL_PLANE_KEY_RING_NAME \
  --location $CONTROL_PLANE_LOCATION \
  --purpose "encryption" \
  --project $PROJECT_ID
       
      gcloud kms keys create $CONSUMER_DATA_KEY_NAME \
  --keyring $CONSUMER_DATA_KEY_RING_NAME \
  --location $CONSUMER_DATA_REGION \
  --purpose "encryption" \
  --project $PROJECT_ID

      Questo comando crea la chiave e la aggiunge al keyring.

      Recupera l'ID chiave:

      gcloud kms keys list \
--location=$CONTROL_PLANE_LOCATION \
--keyring=$CONTROL_PLANE_KEY_RING_NAME \
--project=$PROJECT_ID
       
      gcloud kms keys list \
--location=$CONSUMER_DATA_REGION \
--keyring=$CONSUMER_DATA_KEY_RING_NAME \
--project=$PROJECT_ID

      L'ID chiave ha la seguente sintassi (simile a un percorso file):

      projects/PROJECT_ID/locations/CONTROL_PLANE_LOCATION/keyRings/CONTROL_PLANE_KEY_RING_NAME/cryptoKeys/CONTROL_PLANE_KEY_NAME
       
      projects/PROJECT_ID/locations/CONSUMER_DATA_REGION/keyRings/CONSUMER_DATA_KEY_RING_NAME/cryptoKeys/CONSUMER_DATA_KEY_NAME
    5. Inserisci l'ID chiave in una variabile di ambiente. Utilizzerai questa variabile in un comando successivo: 
      CONTROL_PLANE_KEY_ID=YOUR_CONTROL_PLANE_KEY_ID

      CONSUMER_DATA_KEY_ID=YOUR_CONSUMER_DATA_KEY_ID
    6. Concedi all'agente di servizio Apigee l'accesso per utilizzare la nuova chiave: 
      gcloud kms keys add-iam-policy-binding $CONTROL_PLANE_KEY_NAME \
  --location $CONTROL_PLANE_LOCATION \
  --keyring $CONTROL_PLANE_KEY_RING_NAME \
  --member "serviceAccount:service-$PROJECT_NUMBER@gcp-sa-apigee.iam.gserviceaccount.com" \
  --role roles/cloudkms.cryptoKeyEncrypterDecrypter \
  --project $PROJECT_ID

      gcloud kms keys add-iam-policy-binding $CONSUMER_DATA_KEY_NAME \
 --location $CONSUMER_DATA_REGION \
 --keyring $CONSUMER_DATA_KEY_RING_NAME \
 --member "serviceAccount:service-$PROJECT_NUMBER@gcp-sa-apigee.iam.gserviceaccount.com" \
 --role roles/cloudkms.cryptoKeyEncrypterDecrypter \
 --project $PROJECT_ID

      Questo comando associa la chiave all'agente di servizio Apigee. Al termine corretto di questa richiesta, gcloud risponde con qualcosa di simile al seguente:

      Updated IAM policy for key [runtime].
bindings:
- members:
  - serviceAccount:service-1234567890@gcp-sa-apigee.iam.gserviceaccount.com
  role: roles/cloudkms.cryptoKeyEncrypterDecrypter
etag: BwWqgEuCuwk=
version: 1

      Se ricevi un messaggio di errore simile al seguente:

      INVALID_ARGUMENT: Role roles/cloudkms.cryptokms.cryptoKeyEncrypterDecrypter is not supported for this resource.

      Assicurati di aver utilizzato il numero di progetto e non il nome del progetto nel servizio l'indirizzo email dell'account.

    Vedi anche: Risoluzione dei problemi relativi a CMEK.

  3. Crea l'organizzazione inviando la seguente richiesta all'API organizations di Apigee:

    Nessuna residenza dei dati

    curl "https://apigee.googleapis.com/v1/organizations?parent=projects/$PROJECT_ID"  \
  -H "Authorization: Bearer $AUTH" \
  -X POST \
  -H "Content-Type:application/json" \
  -d '{
    "name":"'"$PROJECT_ID"'",
    "analyticsRegion":"'"$ANALYTICS_REGION"'",
    "runtimeType":"CLOUD",
    "billingType":"'"$BILLING_TYPE"'",
    "authorizedNetwork":"'"$NETWORK_NAME"'",
    "runtimeDatabaseEncryptionKeyName":"'"$RUNTIMEDB_KEY_ID"'"
  }'

    Dove:

    • -d definisce il payload di dati per la richiesta. Questo payload deve includere quanto segue:

      • name: identifica la nuova organizzazione. Deve avere lo stesso nome dell'ID progetto.

      • analyticsRegion: specifica la località fisica in cui vengono eseguiti i tuoi dati verranno archiviati.

      • runtimeType: imposta questo valore su CLOUD.
      • billingType: specifica il tipo di fatturazione dell'organizzazione creata.
      • authorizedNetwork: identifica la rete di peering a cui specificato in Configurare il networking di servizi.
      • runtimeDatabaseEncryptionKeyName: l'ID della chiave di crittografia dell'applicazione che hai creato nel passaggio precedente. Ricorda che l'ID è strutturato come un percorso file. Ad esempio:
        projects/my-project/locations/us-west1/keyRings/my-key-ring/cryptoKeys/my-key

    Residenza dei dati

    Crea un'organizzazione utilizzando l'API:

    curl "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations?parent=projects/$PROJECT_ID"  \
  -H "Authorization: Bearer $AUTH" \
  -X POST \
  -H "Content-Type:application/json" \
  -d '{
    "name":"'"$PROJECT_ID"'",
    "runtimeType":"CLOUD",
    "billingType":"'"$BILLING_TYPE"'",
    "controlPlaneEncryptionKeyName":"'"$CONTROL_PLANE_KEY_ID"'",
    "apiConsumerDataLocation":"'"$CONSUMER_DATA_REGION"'",
    "apiConsumerDataEncryptionKeyName":"'"$CONSUMER_DATA_KEY_ID"'",
    "authorizedNetwork":"'"$NETWORK_NAME"'",
    "runtimeDatabaseEncryptionKeyName":"'"$RUNTIMEDB_KEY_ID"'"
  }'

    Dove:

    -d definisce il payload di dati per la richiesta. Questo payload deve includere le seguenti:

    • name: identifica la nuova organizzazione. Deve essere uguale come ID progetto.
    • runtimeType: imposta questo valore su CLOUD.
    • billingType: specifica il tipo di fatturazione dell'organizzazione creata.
    • controlPlaneEncryptionKeyName: è l'ID chiave del piano di controllo.
    • apiConsumerDataLocation: devi specificare anche una sottoregione che deve essere utilizzata da risorse interne. Consulta Regioni di residenza dei dati per i valori supportati.
    • apiConsumerDataEncryptionKeyName: è l'ID chiave della regione dei dati dei consumatori.
    • authorizedNetwork: identifica la rete di peering a cui specificato in Configurare il networking di servizi.
    • runtimeDatabaseEncryptionKeyName: l'ID della chiave di crittografia dell'applicazione che hai creato nel passaggio precedente. Ricorda che l'ID è strutturato come un percorso file. Ad esempio:
      projects/my-project/locations/us-west1/keyRings/my-key-ring/cryptoKeys/my-key

    Dopo aver eseguito questo comando, Apigee avvia un'operazione a lunga esecuzione, che può richiedere alcuni minuti.

    Se visualizzi un messaggio di errore, verifica l'uso delle virgolette intorno i valori delle variabili nel payload. Assicurati di avere virgolette doppie, singole e doppie intorno alla variabile $PROJECT_ID, come mostrato nell'esempio seguente:

    "'"$PROJECT_ID"'"

    Se utilizzi stringhe semplici (non variabili di ambiente) per i valori delle richieste, puoi racchiudili tra virgolette doppie all'interno stringa di payload racchiusa tra virgolette singole, come mostra l'esempio seguente:

    '{ "name":"my-gcp-project", ... }'
  4. Attendi qualche minuto.
  5. Per controllare lo stato della tua richiesta di creazione, puoi inviare una richiesta GET ad Apigee Elenca l'API Organization, come mostrato nell'esempio seguente:

    Nessuna residenza dei dati

    curl -H "Authorization: Bearer $AUTH" "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID"

    Residenza dei dati

    curl -H "Authorization: Bearer $AUTH" "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID"

    Se visualizzi questa risposta, significa che la creazione dell'organizzazione non è ancora stata completata: 

    {
  "error": {
    "code": 403,
    "message": "Permission denied on resource \"organizations/apigee-docs-m\" (or it may not exist)",
    "status": "PERMISSION_DENIED"
  }
}

    Se Apigee ha creato correttamente una nuova organizzazione, riceverai una risposta simile alla seguente:

    Nessuna residenza dei dati

    {
  "name": "my-cloud-project",
  "createdAt": "1592586495539",
  "lastModifiedAt": "1592586495539",
  "environments": [],
  "properties": {
    "property": [
      {
        "name": "features.hybrid.enabled",
        "value": "true"
      },
      {
        "name": "features.mart.connect.enabled",
        "value": "true"
      }
    ]
  },
  "analyticsRegion": "us-west1",
  "runtimeType": "CLOUD",
  "subscriptionType": "PAID",
  "caCertificate": "YOUR_CERTIFICATE",
  "authorizedNetwork": "my-network",
  "projectId": "my-cloud-project"
}

    Residenza dei dati

      {
    "name": "my-cloud-project",
    "createdAt": "1681412783749",
    "lastModifiedAt": "1681412783749",
    "environments": [
      "test-env"
    ],
    "properties": {
      "property": [
        {
          "name": "features.mart.connect.enabled",
          "value": "true"
        },
        {
          "name": "features.hybrid.enabled",
          "value": "true"
        }
      ]
    },
    "authorizedNetwork": "default",
    "runtimeType": "CLOUD",
    "subscriptionType": "PAID",
    "caCertificate": "YOUR_CERTIFICATE",
    "runtimeDatabaseEncryptionKeyName": "projects/my-cloud-project/locations/us/keyRings/my-key-ring/cryptoKeys/my-key-name",
    "projectId": "my-cloud-project",
    "state": "ACTIVE",
    "billingType": "PAYG",
    "addonsConfig": {
      "advancedApiOpsConfig": {},
      "integrationConfig": {},
      "monetizationConfig": {},
      "connectorsPlatformConfig": {}
    },
    "apiConsumerDataEncryptionKeyName": "projects/my-cloud-project/locations/us-central1/keyRings/my-key-ring/cryptoKeys/my-key-name",
    "controlPlaneEncryptionKeyName": "projects/my-cloud-project/locations/us/keyRings/my-key-ring/cryptoKeys/my-key-name",
    "apiConsumerDataLocation": "us-central1",
    "apigeeProjectId": "i0c2a37e80f9850ab-tp"
  }

    Se Apigee restituisce una risposta di errore HTTP, vedi Creazione di un'organizzazione Apigee in corso...