Questa pagina è stata tradotta dall'API Cloud Translation.

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

Questa pagina riguarda Apigee, ma non Apigee ibrido.

Visualizza la documentazione di Apigee Edge.

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

Vedi anche Opzioni di provisioning.

Limitazioni

L'opzione di installazione tramite peering non VPC descritta in questo documento presenta alcune limitazioni:

I Controlli di servizio VPC non sono supportati.
Il peering DNS privato non è supportato.

Per un elenco completo delle funzionalità e degli approcci al networking che sono e non sono supportati per il peering non VPC, vedi Come scegliere un'opzione di networking.

Riepilogo dei passaggi

Ecco la procedura di provisioning:

Passaggio 1: definisci le variabili di ambiente: configura gcloud e definisci le variabili di ambiente. Google Cloud CLI gestisce l'autenticazione, la configurazione locale, il flusso di lavoro degli sviluppatori e le interazioni con le API Google Cloud.
Passaggio 2: abilita le API: Apigee richiede l'abilitazione di diverse API Google Cloud.
Passaggio 3: crea l'identità del servizio Apigee: questo account di servizio viene utilizzato dalle librerie client di Google Cloud per l'autenticazione con le API Google Cloud.
Passaggio 4: crea un'organizzazione: un'organizzazione Apigee (talvolta definita organizzazione) è il container di primo livello in Apigee. Include tutti gli ambienti e i gruppi di ambienti, gli utenti, i proxy API e le risorse correlate.
Passaggio 5: crea un'istanza di runtime: un'istanza, o runtime, è la posizione in cui sono archiviati il tuo progetto e i relativi servizi. Fornisce l'endpoint rivolto agli utenti per i tuoi servizi.
Passaggio 6: crea un ambiente: prima che le API esposte siano accessibili sulla rete, è necessario eseguire il deployment di un proxy API in un ambiente e poi aggiungerlo a un gruppo di ambienti.
Passaggio 7: configura il routing: consenti l'accesso esterno o solo interno all'API.
Passaggio 8: esegui il deployment di un proxy di esempio: testa il provisioning eseguendo il deployment e chiamando un proxy API.

Passaggio 1: definizione delle variabili di ambiente

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

Assicurati di aver completato i requisiti di configurazione elencati in Prima di iniziare.
Devi avere installato Cloud SDK. Se è necessario installarlo, consulta Installazione di Cloud SDK.
Inizializza Cloud SDK, come descritto in Inizializzare gcloud CLI, oppure assicurati che il progetto Google Cloud che hai creato nella sezione Prerequisiti sia quello predefinito per gcloud.
Definisci le seguenti variabili di ambiente nel terminale di comando. Seleziona la scheda che corrisponde al tipo di organizzazione di cui hai bisogno: Nessuna residenza dei dati o con Residenza dei dati:
Suggerimento: salva le variabili di ambiente in un file di testo in modo da poterle ripristinarle facilmente, se necessario.
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"
```
Nota: se stai eseguendo il provisioning di una nuova organizzazione Apigee all'interno di un progetto Google Cloud con un vincolo di località delle risorse applicato in un criterio dell'organizzazione, verifica che il vincolo di località sia impostato su global. Poiché il piano di controllo Apigee è un'entità globale per impostazione predefinita, il provisioning non riuscirà se viene applicato un vincolo diverso da global. Per saperne di più, consulta Introduzione alla residenza dei dati.

Dove:
- AUTH definisce l'intestazione Authentication con un token di connessione. Utilizzerai questa intestazione durante la chiamata alle API Apigee. Tieni presente che il token scade dopo un determinato periodo di tempo e quando succede, puoi semplicemente rigenerarlo utilizzando lo stesso comando. Per ulteriori informazioni, consulta la pagina di riferimento per il comando Print-access-token.
- PROJECT_ID è l'ID del 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 località fisica in cui si trova l'istanza Apigee che creerai in seguito. Per un elenco delle località di runtime disponibili, consulta Località Apigee.
  
  Nota: per RUNTIME_LOCATION, assicurati di utilizzare il nome di un'area geografica e non il nome di una zona. Ad esempio, us-west1 è il nome di una regione, mentre us-west1-a è una zona nella regione. Vedi anche Identificare una regione o una zona.
- ANALYTICS_REGION è la posizione fisica in cui verranno archiviati i dati di analisi Apigee. Per un elenco delle regioni disponibili per l'analisi delle API Apigee, consulta le località di Apigee.
  
  Sia RUNTIME_LOCATION che ANALYTICS_REGION possono essere la stessa regione, ma non devono essere necessariamente la stessa.
- 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.
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"
```
Importante: quando utilizzi la residenza dei dati, la località del piano di controllo è la regione che la contiene. Tutte le altre regioni devono trovarsi all'interno della località del piano di controllo. Quando la località del piano di controllo è us, anche la regione dei dati consumer e la località di runtime devono trovarsi all'interno di us. Ad esempio, us-west1 è accettabile, dove europe-west1 non lo è.

Dove:
- AUTH definisce l'intestazione Authentication con un token di connessione. Utilizzerai questa intestazione durante la chiamata alle API Apigee. Tieni presente che il token scade dopo un determinato periodo di tempo e quando succede, puoi semplicemente rigenerarlo utilizzando lo stesso comando. Per ulteriori informazioni, consulta la pagina di riferimento per il comando Print-access-token.
- PROJECT_ID è l'ID del 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 località fisica in cui si trova l'istanza Apigee che creerai in seguito. Per un elenco delle località di runtime disponibili, consulta Località Apigee.
  
  Nota: per RUNTIME_LOCATION, assicurati di utilizzare il nome di un'area geografica e non il nome di una zona. Ad esempio, us-west1 è il nome di una regione, mentre us-west1-a è una zona nella regione. Vedi anche Identificare una regione o una zona.
  La località di runtime deve trovarsi all'interno della località 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 località del piano di controllo disponibili, consulta 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.

(Facoltativo) Controlla il tuo lavoro richiamando i valori che hai appena impostato. Tieni presente che quando vuoi utilizzare una variabile nei tuoi comandi, fai precedere il nome della variabile dal simbolo del 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 tuoi comandi echo dovrebbero avere il seguente aspetto:

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

Passaggio 2: attivazione delle API

Autorizzazioni richieste per questa attività

Puoi assegnare al provisioner Apigee un ruolo predefinito che include le autorizzazioni necessarie per completare questa attività oppure concedere autorizzazioni più granulari per fornire il privilegio minimo necessario. Vedi Ruoli predefiniti e Autorizzazioni per l'abilitazione delle API.

Apigee richiede l'abilitazione di diverse API Google Cloud. Abilitale eseguendo questo comando services enable:

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

(Facoltativo) Per verificare 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 abilitato.

Passaggio 3: crea l'identità del servizio Apigee

Crea l'identità di servizio Apigee:

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

Verifica che l'agente sia stato creato correttamente. La risposta dovrebbe mostrare il nome dell'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: creazione di un'organizzazione

Autorizzazioni richieste per questa attività

Prima di poter creare un'organizzazione, devi creare un keyring e una chiave di crittografia del database runtime (vedi passaggio 1) e, se utilizzi la residenza dei dati, i keyring e le chiavi di crittografia del piano di controllo (vedi il passaggio 2). Queste chiavi Cloud KMS criptano i dati archiviati e replicati nelle località di runtime e del piano di controllo. Apigee utilizza queste entità per criptare i dati delle applicazioni, come KVM, cache e client secret, che vengono poi archiviati nel database. Per maggiori informazioni, consulta Informazioni sulle chiavi di crittografia Apigee.

Creare un keyring e una chiave di crittografia del database di runtime.
1. Definisci una variabile di ambiente per la località dell'anello e della chiave di crittografia del database del runtime. Questo contribuisce a garantire coerenza quando li crei e ti consente di seguire più facilmente la documentazione.
  
  Il valore è la posizione fisica in cui sono archiviati il keyring e la chiave di crittografia del database del runtime.
  Regione singola
  
  Configurazioni a regione singola (in cui è presente 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 essere necessariamente così. Tuttavia, se le prestazioni sono uguali, potrebbero esserci un vantaggio in termini di prestazioni.
  Più regioni
  
  Configurazioni multiregionali: scegli tra le località con più regioni supportate (ad esempio 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 keyring deve essere univoco per la tua organizzazione. Se crei una seconda regione o una regione successiva, il nome non può essere uguale ai nomi di altri keyring.
```
RUNTIMEDB_KEY_RING_NAME=YOUR_DB_KEY_RING_NAME
RUNTIMEDB_KEY_NAME=YOUR_DB_KEY_NAME
```
3. (Facoltativo) Controlla il tuo lavoro richiamando i valori che hai appena impostato. Ricorda che quando vuoi utilizzare una variabile nei tuoi comandi, fai precedere il nome della variabile dal simbolo del 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 località della chiave di crittografia del database di runtime Apigee supporta tutte le località di Cloud KMS 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 un messaggio 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 nell'indirizzo email dell'account di servizio.
Se utilizzi la residenza dei dati, crea un keyring e una chiave di crittografia del piano di controllo. Se non utilizzi la residenza dei dati, vai al passaggio 3.
Nota: questo passaggio è obbligatorio solo se hai selezionato us (multiple regions in us) o eu (multiple regions in European Union) come giurisdizione di hosting del piano di controllo. Se hai selezionato un'altra regione, vai al passaggio 3.

Per creare un keyring e una chiave di crittografia del piano di controllo, segui questi passaggi.

Definisci una variabile di ambiente per la località della chiave e dell'anello 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 località fisica in cui verranno archiviati i dati del piano di controllo Apigee. Per un elenco delle località del piano di controllo disponibili, consulta 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.
Definisci le variabili di ambiente per i keyring e i nomi delle chiavi del database del piano di controllo.

Il nome del keyring 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 che utilizzerai per identificare il keyring di crittografia del piano di controllo.
- 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.

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

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

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
```

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. Una volta completata correttamente 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 nell'indirizzo email dell'account di servizio.

Vedi anche: Risoluzione dei problemi CMEK.

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"'",
    "disableVpcPeering":"true",
    "runtimeDatabaseEncryptionKeyName":"'"$RUNTIMEDB_KEY_ID"'"
  }'
```
Dove:
- -d definisce il payload dei dati per la richiesta. Questo payload deve includere quanto segue:
  - name: identifica la nuova organizzazione. Deve essere uguale al nome del tuo ID progetto.
  - analyticsRegion: specifica la località fisica in cui verranno archiviati i dati di analisi.
  - runtimeType: imposta questo valore su CLOUD.
  - billingType: specifica il tipo di fatturazione dell'organizzazione creata.
  - disableVpcPeering: imposta su true se non vuoi utilizzare il peering VPC. Predefinita: false
  - runtimeDatabaseEncryptionKeyName: l'ID della chiave di crittografia dell'applicazione che hai creato nel passaggio precedente. Ricorda che l'ID è strutturato come un percorso di 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"'",
    "disableVpcPeering":"true",
    "runtimeDatabaseEncryptionKeyName":"'"$RUNTIMEDB_KEY_ID"'"
  }'
```
Dove:

-d definisce il payload dei dati per la richiesta. Questo payload deve includere quanto segue:
- name: identifica la nuova organizzazione. Deve essere uguale al nome del tuo 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 anche specificare una regione secondaria per l'utilizzo da parte delle risorse interne. Per i valori supportati, consulta Regioni di residenza dei dati.
- apiConsumerDataEncryptionKeyName: è l'ID chiave della regione di dati del consumatore.
- disableVpcPeering: imposta su true se non vuoi utilizzare il peering VPC. Predefinita: false
- runtimeDatabaseEncryptionKeyName: l'ID della chiave di crittografia dell'applicazione che hai creato nel passaggio precedente. Ricorda che l'ID è strutturato come un percorso di 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, il cui completamento può richiedere alcuni minuti.

Se ricevi un messaggio di errore, assicurati di utilizzare le virgolette intorno ai valori della variabile nel payload dei dati. Assicurati di racchiudere la variabile $PROJECT_ID tra virgolette doppie singole e doppie, come mostrato nell'esempio seguente:
```
"'"$PROJECT_ID"'"
```
Se utilizzi stringhe semplici (non variabili di ambiente) per i valori delle richieste, puoi racchiuderli tra virgolette doppie all'interno della stringa di payload tra virgolette singole, come mostra l'esempio seguente:
```
'{ "name":"my-gcp-project", ... }'
```
Attendi qualche minuto.
Per controllare lo stato della richiesta di creazione, puoi inviare una richiesta GET all'API List Organization di Apigee, come mostra l'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 vedi 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 l'operazione riesce, l'oggetto di risposta indicherà "state": "ACTIVE" e potrai andare al passaggio successivo.

Se Apigee restituisce una risposta di errore HTTP, consulta Creazione di un'organizzazione Apigee.

Suggerimento: per elencare le organizzazioni Apigee e i progetti Google Cloud associati a cui hai l'autorizzazione ad accedere, invia una richiesta GET al seguente endpoint utilizzando l'API delle organizzazioni:

Nessuna residenza dei dati:

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

Residenza dei dati:

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

Apigee restituisce un elenco di progetti, come mostra l'esempio seguente:

{
  "organizations": [
    {
      "organization": "my-cloud-project",
      "projectIds": [
        "my-cloud-project"
      ],
      "projectId": "my-cloud-project",
      "location": "northamerica-northeast1"
    },
    {
      "organization": "my-cloud-project-2",
      "projectIds": [
        "my-cloud-project-2"
      ],
      "projectId": "my-cloud-project-2",
      "location": "northamerica-northeast1"
    }
  ]
}

Passaggio 5: creazione di un'istanza di runtime

Autorizzazioni richieste per questa attività

Un'istanza di runtime è l'area in cui vengono archiviati il tuo progetto Apigee e i servizi correlati; fornisce l'endpoint rivolto agli utenti per i tuoi servizi. Per creare una nuova istanza di runtime:

Verifica che Apigee abbia terminato la creazione della tua organizzazione. Hai inviato una richiesta per creare una nuova organizzazione in Crea un'organizzazione Apigee, ma devi assicurarti che sia fatto prima di continuare.

Per farlo, invia la seguente richiesta all'API delle organizzazioni:
Nessuna residenza dei dati
```
curl -i -H "Authorization: Bearer $AUTH" \
    "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID"
```
Residenza dei dati
```
curl -i -H "Authorization: Bearer $AUTH" \
    "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID"
```
Se l'organizzazione esiste (e disponi delle autorizzazioni appropriate per visualizzarla), Apigee risponde fornendo i relativi dettagli. Se Apigee risponde con un errore, attendi un paio di minuti e invia di nuovo la richiesta.
Analogamente all'attività precedente in cui hai creato una chiave di crittografia per il database, ora devi creare una chiave Cloud KMS utilizzata per criptare i dati sul lato server. Per iniziare, definisci le seguenti variabili di ambiente:
```
INSTANCE_NAME=YOUR_INSTANCE_NAME
RUNTIME_LOCATION=YOUR_RUNTIME_LOCATION
DISK_KEY_RING_NAME=YOUR_DISK_KEY_RING_NAME
DISK_KEY_NAME=YOUR_DISK_KEY_NAME
```

Dove:

INSTANCE_NAME: il nome della nuova istanza. Ad esempio, my-runtime-instance. Il nome deve iniziare con una lettera minuscola, può contenere fino a 32 caratteri e può includere solo lettere minuscole, numeri e trattini. Non può iniziare o terminare con un trattino e deve avere una lunghezza di almeno due caratteri.
Suggerimento: il nome dell'istanza deve corrispondere alla seguente espressione regolare:
```
^[a-z][a-z\-\d]{0,30}[a-z\d]$
```
RUNTIME_LOCATION è la posizione fisica in cui è ospitato il cluster. Per valori validi si intende qualsiasi località consentita da Compute Engine. (Vedi Regioni e zone disponibili.) Questo esempio utilizza us-west1.
DISK_KEY_RING_NAME è il nome del keyring di crittografia del disco.
DISK_KEY_NAME è il nome della chiave di crittografia del disco.

Crea una chiave di crittografia del disco:
1. Crea un nuovo keyring del disco:
```
gcloud kms keyrings create $DISK_KEY_RING_NAME \
  --location $RUNTIME_LOCATION \
  --project $PROJECT_ID
```
  Il keyring del disco deve essere impostato nella stessa località dell'istanza. Ogni istanza e keyring devono avere la propria località.
2. Crea una nuova chiave del disco:
```
gcloud kms keys create $DISK_KEY_NAME \
  --keyring $DISK_KEY_RING_NAME \
  --location $RUNTIME_LOCATION \
  --purpose "encryption" \
  --project $PROJECT_ID
```
  È possibile fare riferimento alla chiave tramite il percorso della chiave. Puoi ottenere il percorso della chiave con il seguente comando:
```
gcloud kms keys list \
  --location=$RUNTIME_LOCATION \
  --keyring=$DISK_KEY_RING_NAME \
  --project=$PROJECT_ID
```
  Il percorso della chiave è simile al seguente:
```
projects/PROJECT_ID/locations/RUNTIME_LOCATION/keyRings/my-disk-key-ring/cryptoKeys/my-disk-key
```
3. Inserisci il percorso della chiave in una variabile di ambiente. Utilizzerai questa variabile in un comando successivo:
```
DISK_KEY_ID=YOUR_DISK_KEY_ID
```
  Ad esempio: DISK_KEY_ID=projects/my-project/locations/us-west1/keyRings/my-key-ring/cryptoKeys/my-key
4. Concedi all'agente di servizio Apigee l'accesso per utilizzare la nuova chiave:
```
gcloud kms keys add-iam-policy-binding $DISK_KEY_NAME \
  --location $RUNTIME_LOCATION \
  --keyring $DISK_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.
Per ulteriori informazioni, consulta Informazioni sulle chiavi di crittografia Apigee.
Crea una nuova istanza di runtime per il tuo progetto inviando una richiesta POST all'API Instances di Apigee:
Nessuna residenza dei dati
```
curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances" \
  -X POST -H "Authorization: Bearer $AUTH" \
  -H "Content-Type:application/json" \
  -d '{
    "name":"'"$INSTANCE_NAME"'",
    "location":"'"$RUNTIME_LOCATION"'",
    "diskEncryptionKeyName":"'"$DISK_KEY_ID"'",
    "consumerAcceptList":["'"$PROJECT_ID"'"]
  }'
```
Residenza dei dati
```
curl "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances" \
  -X POST -H "Authorization: Bearer $AUTH" \
  -H "Content-Type:application/json" \
  -d '{
    "name":"'"$INSTANCE_NAME"'",
    "location":"'"$RUNTIME_LOCATION"'",
    "diskEncryptionKeyName":"'"$DISK_KEY_ID"'",
    "consumerAcceptList":["'"$PROJECT_ID"'"]
  }'
```
Dove:
- consumerAcceptList (Facoltativo) Specifica un elenco di ID progetto Google Cloud che possono connettersi privatamente al collegamento al servizio del VPC Apigee. Il collegamento al servizio è un'entità utilizzata con Google Cloud Private Service Connect per consentire ai producer di servizi (in questo caso, Apigee) di esporre i servizi ai consumer (in questo caso uno o più progetti Cloud di tua proprietà). Per impostazione predefinita, utilizziamo il progetto Cloud già associato alla tua organizzazione Apigee. Ad esempio: "consumerAcceptList": ["project1", "project2", "project3"]
  Tieni presente che puoi anche impostare e modificare l'elenco dei progetti accettati nella UI dell'istanza. Per maggiori dettagli, consulta Gestione delle istanze.
Il completamento di questa richiesta può richiedere fino a 20 minuti perché Apigee deve creare e avviare un nuovo cluster Kubernetes, installare le risorse Apigee su quel cluster e configurare il bilanciamento del carico.

Se Apigee restituisce un errore, consulta Creazione di una nuova istanza.

Per controllare lo stato della richiesta di creazione dell'istanza di runtime, esegui questo comando. Quando lo stato è ATTIVO, puoi andare al passaggio successivo.

Nessuna residenza dei dati

curl -i -X GET -H "Authorization: Bearer $AUTH" \
    "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances/$INSTANCE_NAME"

Residenza dei dati

curl -i -X GET -H "Authorization: Bearer $AUTH" \
    "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances/$INSTANCE_NAME"

Passaggio 6: creazione di un ambiente

Autorizzazioni richieste per questa attività

Per creare un ambiente e collegarlo al runtime dalla riga di comando:

Definisci le variabili di ambiente da utilizzare in questa sezione. Le variabili di ambiente specifiche che creerai dipenderanno dal fatto che tu stia creando un ambiente per un'organizzazione in abbonamento o con pagamento a consumo.
Abbonamento

Per un ambiente con abbonamento, crea queste variabili:
```
ENVIRONMENT_NAME="YOUR_ENV_NAME"
ENV_GROUP_NAME="YOUR_ENV_GROUP_NAME"
ENV_GROUP_HOSTNAME="YOUR_ENV_GROUP_HOSTNAME"
```
Dove:
- ENVIRONMENT_NAME è il nome di una stringa. Ad esempio: test
- ENV_GROUP_NAME è il nome di una stringa. Ad esempio: test-group
- ENV_GROUP_HOSTNAME è un nome host di dominio valido. Ad esempio: foo.example.com
Pay-as-you-go

Per un ambiente con pagamento a consumo, crea queste variabili:
```
ENVIRONMENT_NAME="YOUR_ENV_NAME"
ENVIRONMENT_TYPE="YOUR_ENV_TYPE"
ENV_GROUP_NAME="YOUR_ENV_GROUP_NAME"
ENV_GROUP_HOSTNAME="YOUR_ENV_GROUP_HOSTNAME"
```
Dove:
- ENVIRONMENT_NAME è il nome di una stringa. Ad esempio: test
- ENVIRONMENT_TYPE è il tipo di ambiente per questo ambiente ed è applicabile solo agli utenti Pay-as-you-go, che devono specificare uno di questi valori: BASE, INTERMEDIATE o COMPREHENSIVE. Gli altri utenti devono omettere il tipo di ambiente.
- ENV_GROUP_NAME è il nome di una stringa. Ad esempio: test-group
- ENV_GROUP_HOSTNAME è un nome host di dominio valido. Ad esempio: foo.example.com

Crea un nuovo ambiente con l'API Environments. I comandi specifici da utilizzare dipendono dal fatto che tu stia creando un ambiente per un'organizzazione in abbonamento o con pagamento a consumo.

Abbonamento

Per un nuovo ambiente di sottoscrizione, utilizza il comando seguente:

Nessuna residenza dei dati

curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments" \
    -H "Authorization: Bearer $AUTH" \
    -X POST \
    -H "Content-Type:application/json" \
    -d '{
      "name":"'"$ENVIRONMENT_NAME"'"
  }'

Residenza dei dati

curl "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments" \
    -H "Authorization: Bearer $AUTH" \
    -X POST \
    -H "Content-Type:application/json" \
    -d '{
      "name":"'"$ENVIRONMENT_NAME"'"
  }'

Apigee crea un nuovo ambiente.

Pay-as-you-go

Per un nuovo ambiente con pagamento a consumo, utilizza il seguente comando:

Nessuna residenza dei dati

curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments" \
    -H "Authorization: Bearer $AUTH" \
    -X POST \
    -H "Content-Type:application/json" \
    -d '{
      "name":"'"$ENVIRONMENT_NAME"'",
      "type":"'"$ENVIRONMENT_TYPE"'"
  }'

Residenza dei dati

curl "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments" \
    -H "Authorization: Bearer $AUTH" \
    -X POST \
    -H "Content-Type:application/json" \
    -d '{
      "name":"'"$ENVIRONMENT_NAME"'",
      "type":"'"$ENVIRONMENT_TYPE"'"
  }'

Apigee crea un nuovo ambiente.

Prima di continuare, verifica che Apigee abbia terminato di creare il nuovo ambiente chiamando l'API Environments:

Nessuna residenza dei dati

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

Residenza dei dati

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

Apigee risponde con un elenco di ambienti disponibili; ad esempio, se il nome del tuo ambiente è test, Apigee risponde con quanto segue:

[
  "test"
]

Suggerimento: puoi controllare lo stato di un ambiente specifico inviando un comando come il seguente:

Nessuna residenza dei dati:

curl -i -X GET -H "Authorization: Bearer $AUTH" \
  "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments/$ENVIRONMENT_NAME"

Residenza dei dati:

curl -i -X GET -H "Authorization: Bearer $AUTH" \
              "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments/$ENVIRONMENT_NAME"

Apigee risponde solo con dettagli su quell'ambiente, ad esempio:

{
  "name": "my-cloud-project",
  "createdAt": "1592589683002",
  "lastModifiedAt": "1592589683002",
  "state": "ACTIVE"
}

Collega il nuovo ambiente all'istanza di runtime:

Nessuna residenza dei dati

curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances/$INSTANCE_NAME/attachments" \
    -X POST -H "Authorization: Bearer $AUTH" \
    -H "content-type:application/json" \
    -d '{
      "environment":"'"$ENVIRONMENT_NAME"'"
    }'

Residenza dei dati

curl "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances/$INSTANCE_NAME/attachments" \
    -X POST -H "Authorization: Bearer $AUTH" \
    -H "content-type:application/json" \
    -d '{
      "environment":"'"$ENVIRONMENT_NAME"'"
    }'

Il completamento di questa operazione può richiedere diversi minuti. Per verificare se l'allegato è stato completato, esegui questo comando:

Nessuna residenza dei dati

curl -i -H "Authorization: Bearer $AUTH" \
  "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances/$INSTANCE_NAME/attachments"

Residenza dei dati

curl -i -H "Authorization: Bearer $AUTH" \
  "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances/$INSTANCE_NAME/attachments"

Quando viene visualizzato un output come il seguente, puoi andare al passaggio successivo:

{
  "attachments": [
    {
      "name": "ed628782-c893-4095-b71c-f4731805290a",
      "environment": "test",
      "createdAt": "1641604447542"
    }
  ]
}

Crea un nuovo gruppo di ambienti utilizzando il comando seguente. Per maggiori informazioni, consulta Informazioni sugli ambienti e sui gruppi di ambienti:

Nessuna residenza dei dati

curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups" \
    -H "Authorization: Bearer $AUTH" \
    -X POST \
    -H "Content-Type:application/json" \
    -d '{
      "name": "'"$ENV_GROUP_NAME"'",
      "hostnames":["'"$ENV_GROUP_HOSTNAME"'"]
  }'

Residenza dei dati

curl "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups" \
    -H "Authorization: Bearer $AUTH" \
    -X POST \
    -H "Content-Type:application/json" \
    -d '{
      "name": "'"$ENV_GROUP_NAME"'",
      "hostnames":["'"$ENV_GROUP_HOSTNAME"'"]
  }'

Attendi il completamento dell'operazione. Puoi controllare lo stato del tuo nuovo gruppo utilizzando una richiesta come la seguente:

Nessuna residenza dei dati

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

Residenza dei dati

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

Collega il nuovo ambiente al nuovo gruppo di ambienti con il seguente comando:

Nessuna residenza dei dati

curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups/$ENV_GROUP_NAME/attachments" \
    -X POST \
    -H "Authorization: Bearer $AUTH" \
    -H "content-type:application/json" \
    -d '{
      "environment":"'"$ENVIRONMENT_NAME"'"
  }'

Residenza dei dati

curl "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups/$ENV_GROUP_NAME/attachments" \
    -X POST \
    -H "Authorization: Bearer $AUTH" \
    -H "content-type:application/json" \
    -d '{
      "environment":"'"$ENVIRONMENT_NAME"'"
  }'

Per controllare lo stato dell'operazione, chiama questa API:

Nessuna residenza dei dati

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

Residenza dei dati

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

Passaggio 7: configurazione del routing

In questo passaggio configurerai il modo in cui le applicazioni client comunicano con Apigee. Il traffico da client ad Apigee è anche chiamato traffico "verso nord". Le opzioni di configurazione associate a nord sono le seguenti. Vai all'opzione di configurazione che vuoi utilizzare ed esegui i relativi passaggi:

Tipo di accesso	Descrizione del processo di configurazione e deployment
Interno con PSC (novità)	Consenti solo l'accesso interno ai proxy API da qualsiasi progetto Google Cloud utilizzando Private Service Connect (PSC). PSC consente una connessione privata tra un producer di servizi (Apigee) e un consumer di servizi (il progetto VPC in peering e/o uno o più altri progetti Cloud controllati da te). Con questo metodo, le richieste passano attraverso un endpoint di servizio o un bilanciatore del carico interno a livello di regione a un singolo punto di collegamento, chiamato collegamento al servizio. Questa configurazione consente ai tuoi client interni di inviare richieste proxy API Apigee da qualsiasi macchina abilitata in rete.
Esterno con PSC (novità)	Consenti l'accesso esterno ai proxy API utilizzando Private Service Connect (PSC). Utilizza Private Service Connect (PSC) per abilitare la connessione privata tra un producer di servizi (Apigee) e un consumer di servizi (il progetto VPC in peering e/o uno o più altri progetti Cloud controllati da te). Con questo metodo, le richieste passano attraverso un bilanciatore del carico esterno globale o un bilanciatore del carico esterno regionale a un singolo punto di collegamento, chiamato collegamento al servizio. Questa configurazione ti consente di inviare richieste proxy API Apigee da qualsiasi macchina abilitata in rete.

Tipo di accesso

Descrizione del processo di configurazione e deployment

Interno con PSC (novità)

Consenti solo l'accesso interno ai proxy API da qualsiasi progetto Google Cloud utilizzando Private Service Connect (PSC).

PSC consente una connessione privata tra un producer di servizi (Apigee) e un consumer di servizi (il progetto VPC in peering e/o uno o più altri progetti Cloud controllati da te). Con questo metodo, le richieste passano attraverso un endpoint di servizio o un bilanciatore del carico interno a livello di regione a un singolo punto di collegamento, chiamato collegamento al servizio. Questa configurazione consente ai tuoi client interni di inviare richieste proxy API Apigee da qualsiasi macchina abilitata in rete.

Esterno con PSC (novità)

Consenti l'accesso esterno ai proxy API utilizzando Private Service Connect (PSC).

Utilizza Private Service Connect (PSC) per abilitare la connessione privata tra un producer di servizi (Apigee) e un consumer di servizi (il progetto VPC in peering e/o uno o più altri progetti Cloud controllati da te). Con questo metodo, le richieste passano attraverso un bilanciatore del carico esterno globale o un bilanciatore del carico esterno regionale a un singolo punto di collegamento, chiamato collegamento al servizio. Questa configurazione ti consente di inviare richieste proxy API Apigee da qualsiasi macchina abilitata in rete.

Ciascuno di questi approcci di routing è presentato nelle istruzioni riportate di seguito.

Routing interno (PSC)

Questa sezione spiega come consentire solo l'accesso interno ai proxy API da qualsiasi progetto Google Cloud utilizzando Private Service Connect (PSC).

Hai due opzioni per configurare l'accesso interno con PSC:

Endpoint di servizio: le richieste passano attraverso un endpoint di servizio a un singolo punto di collegamento, chiamato collegamento di servizio.
Bilanciatore del carico regionale interno: le richieste passano attraverso un bilanciatore del carico HTTP(S) interno regionale. Vedi anche Bilanciamento del carico globale e a livello di regione.

Seleziona la scheda di seguito per la tua scelta di configurazione e segui i passaggi:

Endpoint di servizio

Autorizzazioni richieste per questa attività

Crea un endpoint di servizio PSC per il collegamento al servizio

Recupera il collegamento al servizio dall'istanza creata in precedenza:

Nessuna residenza dei dati

curl -i -X GET -H "Authorization: Bearer $AUTH" \
"https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances"

Residenza dei dati

curl -i -X GET -H "Authorization: Bearer $AUTH" \
"https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances"

Nel seguente output di esempio, il valore serviceAttachment è mostrato in grassetto:

{
  "instances": [
    {
      "name": "us-west1",
      "location": "us-west1",
      "createdAt": "1645731488019",
      "lastModifiedAt": "1646504754219",
      "diskEncryptionKeyName": "projects/my-project/locations/us-west1/keyRings/us-west1/cryptoKeys/dek",
      "state": "ACTIVE",
      "runtimeVersion": "1-7-0-20220228-190814",
      "consumerAcceptList": [
        "my-project"
      ],
      "serviceAttachment": "projects/bfac74a67a320c43a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw1"
    }
  ]
}

Nota: l'ID del progetto che hai utilizzato per creare la tua organizzazione Apigee viene sempre visualizzato nell'elenco consumerAcceptList. Nell'output di esempio mostrato sopra, è l'unico progetto dell'elenco.

Crea un endpoint di servizio PSC che punti al collegamento al servizio che hai ottenuto dal corpo della risposta dell'istanza nel passaggio precedente, come spiegato in Creare un endpoint Private Service Connect.
Provisioning di Apigee completato. Vai a Eseguire il deployment di un proxy di esempio.

Bilanciatore del carico regionale interno

Autorizzazioni richieste per questa attività

Limitazioni: tieni presente le seguenti restrizioni per la configurazione PSC:

Il bilanciatore del carico HTTP(S) esterno globale (classico) non è supportato per questa configurazione.
Per il failover con più NEG PSC, i controlli di integrità attivi non sono supportati. Utilizza invece il rilevamento outlier.
Il numero di progetti Google Cloud che possono connettersi a un'istanza Apigee tramite PSC è limitato a 50 e ogni progetto può creare fino a 20 connessioni. Vedi Configurare il routing. Vedi anche Limiti.
Nota : puoi controllare l'elenco dei progetti Google Cloud connessi a un'istanza mediante il campo consumerAcceptList dell'API instances.
Se un progetto Google Cloud viene rimosso da consumerAcceptList, i NEG PSC esistenti nel progetto rimosso continueranno a funzionare. Tuttavia, eventuali nuovi NEG verranno rifiutati. Devi eliminare i NEG esistenti se rimuovi i progetti associati da consumerAcceptList. In alternativa, puoi ricreare l'istanza Apigee per ricreare il collegamento al servizio nel progetto Apigee.

Passaggio 8a: configura le variabili di ambiente

Le istruzioni in questa sezione utilizzano le variabili di ambiente per fare riferimento alle stringhe utilizzate più volte. Assicurati di aver impostato le variabili in Definisci le variabili di ambiente.

Inoltre, imposta le seguenti variabili di ambiente:

NEG_NAME=YOUR_NEG_NAME"
TARGET_SERVICE=YOUR_TARGET_SERVICE"
NETWORK_NAME=YOUR_NETWORK_NAME"
SUBNET_NAME=YOUR_SUBNET_NAME"

Dove:

NEG_NAME: un nome per il gruppo di endpoint di rete.
TARGET_SERVICE: il collegamento al servizio a cui vuoi connetterti. Ad esempio: projects/bfac7497a40c32a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw7
NETWORK_NAME: (facoltativo) nome della rete in cui viene creato il NEG. Se ometti questo parametro, viene utilizzata la rete del progetto default.
SUBNET_NAME: nome della subnet utilizzata per la connettività privata al producer. Le dimensioni della subnet possono essere ridotte: il NEG PSC richiede solo un IP dalla subnet. Per Apigee, è necessario un solo NEG PSC per regione. La subnet può essere condivisa e utilizzata dalle VM o da altre entità. Se non viene specificata una subnet, gli endpoint di rete possono appartenere a qualsiasi subnet nella regione in cui viene creato il gruppo di endpoint di rete.
Nota: se specifichi il parametro --network,devi specificare anche --subnet.

Passaggio 8b: crea una subnet solo proxy

gcloud compute networks subnets create testproxyonlysubnet \
--purpose=REGIONAL_MANAGED_PROXY --role=ACTIVE --region=$RUNTIME_REGION --network=$NETWORK_NAME \
--range=100.0.0.0/24 --project=$PROJECT_ID

Passaggio 8c: crea un gruppo di endpoint di rete (NEG)

Recupera il collegamento al servizio dall'istanza creata in precedenza:

Nessuna residenza dei dati

curl -i -X GET -H "Authorization: Bearer $AUTH" \
"https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances"

Residenza dei dati

curl -i -X GET -H "Authorization: Bearer $AUTH" \
"https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances"

Nel seguente output di esempio, il valore serviceAttachment è mostrato in grassetto:

{
  "instances": [
    {
      "name": "us-west1",
      "location": "us-west1",
      "createdAt": "1645731488019",
      "lastModifiedAt": "1646504754219",
      "diskEncryptionKeyName": "projects/my-project/locations/us-west1/keyRings/us-west1/cryptoKeys/dek",
      "state": "ACTIVE",
      "runtimeVersion": "1-7-0-20220228-190814",
      "consumerAcceptList": [
        "my-project"
      ],
      "serviceAttachment": "projects/bfac7497a40c32a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw7"
    }
  ]
  }

Creare un NEG Private Service Connect che punti al collegamento al servizio ottenuto dal corpo della risposta dell'istanza nel passaggio precedente.
```
gcloud compute network-endpoint-groups create $NEG_NAME \
--network-endpoint-type=private-service-connect \
--psc-target-service=$TARGET_SERVICE \
--region=$RUNTIME_LOCATION \
--project=$PROJECT_ID
```
Dove $PROJECT_ID può essere il progetto Cloud già associato alla tua organizzazione Apigee o un progetto Cloud incluso in consumerAcceptlist al momento della creazione dell'istanza di runtime Apigee.

Passaggio 8d: configura il bilanciatore del carico interno a livello di regione

Prenota un indirizzo IPv4 interno per il bilanciatore del carico.

gcloud compute addresses create ADDRESS_NAME \
--ip-version=IPV4 --subnet=$SUBNET_NAME \
--region=$RUNTIME_LOCATION --project=$PROJECT_ID

Sostituisci ADDRESS_NAME con un nome per la risorsa dell'indirizzo IP.

Esegui questo comando per visualizzare l'indirizzo IP riservato:

gcloud compute addresses describe ADDRESS_NAME \
--format="get(address)" --region=$RUNTIME_LOCATION --project=$PROJECT_ID

Crea un servizio di backend per il NEG.

gcloud compute backend-services create BACKEND_SERVICE_NAME \
--load-balancing-scheme=INTERNAL_MANAGED \
--protocol=HTTPS \
--region=$RUNTIME_REGION \
--project=$PROJECT_ID

Sostituisci BACKEND_SERVICE_NAME con il nome del servizio di backend.

Aggiungi il servizio di backend al NEG.
```
gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
--network-endpoint-group=$NEG_NAME \
--region=$RUNTIME_LOCATION \
--project=$PROJECT_ID
```
Sostituisci quanto segue:
- NEG_NAME: il nome del gruppo di endpoint di rete.
- BACKEND_SERVICE_NAME con il nome del servizio di backend.
Per creare un bilanciatore del carico HTTPS, devi disporre di una risorsa di certificato SSL da utilizzare nel proxy di destinazione HTTPS.

Utilizza questo comando per creare una risorsa del certificato SSL autogestito. Per creare un certificato SSL autogestito, sono necessari un file di chiave privata locale e un file di certificato locale. Se devi creare questi file, consulta il passaggio 1 sull'utilizzo dei certificati SSL autogestiti.

Nota: i certificati gestiti da Google non sono supportati dal bilanciatore del carico a livello di regione interno.
```
gcloud compute ssl-certificates create CERTIFICATE \
--certificate LB_CERT \
--private-key LB_PRIVATE_KEY
--region=$RUNTIME_LOCATION --project=$PROJECT_ID
```
Sostituisci quanto segue:
- CERTIFICATE: un nome per il certificato.
- LB_CERT: il percorso del file del certificato in formato PEM per il certificato autogestito.
- LB_PRIVATE_KEY: il percorso del file della chiave privata in formato PEM per il certificato autogestito.
Crea una mappa URL per il bilanciatore del carico.

Una mappa URL deve fare riferimento a un servizio di backend predefinito. Imposta come predefinito il servizio di backend che hai appena creato.
```
gcloud compute url-maps create URL_MAP_NAME \
--default-service=DEFAULT_BACKEND_SERVICE_NAME \
--global --project=$PROJECT_ID
```
Sostituisci quanto segue:
- URL_MAP_NAME: un nome per la mappa URL.
- DEFAULT_BACKEND_SERVICE_NAME: il nome del servizio di backend predefinito del bilanciatore del carico. L'impostazione predefinita viene utilizzata quando nessuna regola host corrisponde al nome host richiesto.
Utilizza la risorsa del certificato SSL per creare un proxy HTTPS di destinazione.
```
gcloud compute target-https-proxies create PROXY_NAME \
--url-map=URL_MAP_NAME \
--ssl-certificates=CERTIFICATE \
--region=$RUNTIME_LOCATION --project=$PROJECT_ID
```
Sostituisci quanto segue:
- PROXY_NAME: un nome per il proxy HTTPS di destinazione.
- URL_MAP_NAME: il nome della mappa URL.
- CERTIFICATE: il nome della risorsa del certificato.

Crea la regola di forwarding.

gcloud compute forwarding-rules create FWD_RULE \
--load-balancing-scheme=INTERNAL_MANAGED \
--address=ADDRESS_NAME \
--target-https-proxy=PROXY_NAME \
--ports=443 \
--target-https-proxy-region=$RUNTIME_REGION \
--region=$RUNTIME_REGION
--project=$PROJECT_ID

Sostituisci quanto segue:

FWD_RULE: un nome per la regola di forwarding.
ADDRESS_NAME: la risorsa dell'indirizzo IP che hai prenotato per l'utilizzo per la regola di forwarding.
PROXY_NAME: il nome del proxy HTTPS di destinazione.

Provisioning di Apigee completato. Vai a Deployment di un proxy di esempio.

Routing esterno (PSC)

Questa sezione descrive come configurare il routing esterno utilizzando Private Service Connect (PSC) per consentire la comunicazione tra Apigee e i VPC che controlli. Devi farlo prima di poter inviare una richiesta da un client esterno alla tua istanza di runtime Apigee.

Autorizzazioni richieste per questa attività

Limitazioni: tieni presente le seguenti limitazioni per la configurazione PSC:

Il bilanciatore del carico HTTP(S) esterno globale (classico) non è supportato per questa configurazione.
Per il failover con più NEG PSC, i controlli di integrità attivi non sono supportati. Utilizza invece il rilevamento outlier.
Il numero di progetti Google Cloud che possono connettersi a un'istanza Apigee tramite PSC è limitato a 50 e ogni progetto può creare fino a 20 connessioni. Vedi Configurare il routing. Vedi anche Limiti.
Nota : puoi controllare l'elenco dei progetti Google Cloud connessi a un'istanza mediante il campo consumerAcceptList dell'API instances.
Se un progetto Google Cloud viene rimosso da consumerAcceptList, i NEG PSC esistenti nel progetto rimosso continueranno a funzionare. Tuttavia, eventuali nuovi NEG verranno rifiutati. Devi eliminare i NEG esistenti se rimuovi i progetti associati da consumerAcceptList. In alternativa, puoi ricreare l'istanza Apigee per ricreare il collegamento al servizio nel progetto Apigee.

Passaggio 8b: crea un NEG e configura il bilanciatore del carico

Puoi creare un bilanciatore del carico globale o regionale.

Bilanciatore del carico esterno globale

Configura un bilanciatore del carico HTTP(S) esterno globale (schema di bilanciamento del carico impostato su EXTERNAL_MANAGED).

Anche se il NEG Private Service Connect è a livello di regione, tutti gli altri componenti di bilanciamento del carico in questa configurazione sono globali.

Assicurati di aver impostato le variabili di ambiente in Definisci le variabili di ambiente.

Recupera il collegamento al servizio dall'istanza creata in precedenza:

Nessuna residenza dei dati

curl -i -X GET -H "Authorization: Bearer $AUTH" \
    "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances"

Residenza dei dati

curl -i -X GET -H "Authorization: Bearer $AUTH" \
    "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances"

Nel seguente output di esempio, il valore serviceAttachment è mostrato in grassetto:

{
  "instances": [
    {
      "name": "us-west1",
      "location": "us-west1",
      "host": "10.82.192.2",
      "port": "443",
      "createdAt": "1645731488019",
      "lastModifiedAt": "1646504754219",
      "diskEncryptionKeyName": "projects/my-project/locations/us-west1/keyRings/us-west1/cryptoKeys/dek",
      "state": "ACTIVE",
      "peeringCidrRange": "SLASH_22",
      "runtimeVersion": "1-7-0-20220228-190814",
      "ipRange": "10.82.192.0/22,10.82.196.0/28",
      "consumerAcceptList": [
        "875609189304"
      ],
      "serviceAttachment": "projects/bfac7497a40c32a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw7"
    }
  ]
}

Crea un NEG Private Service Connect che punti al collegamento al servizio ottenuto dal corpo della risposta dell'istanza nel passaggio precedente.
```
  gcloud compute network-endpoint-groups create NEG_NAME \
    --network-endpoint-type=private-service-connect \
    --psc-target-service=TARGET_SERVICE \
    --region=$RUNTIME_LOCATION \
    --network=NETWORK_NAME \
    --subnet=SUBNET_NAME \
    --project=$PROJECT_ID
```
Sostituisci quanto segue:
- NEG_NAME: un nome per il gruppo di endpoint di rete.
- TARGET_SERVICE: il collegamento al servizio a cui vuoi connetterti. Utilizza il valore del collegamento al servizio restituito dal comando precedente. Ad esempio: projects/bfac7497a40c32a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw7
- NETWORK_NAME: (facoltativo) nome della rete in cui viene creato il NEG. Se ometti questo parametro, viene utilizzata la rete del progetto default.
- SUBNET_NAME: nome della subnet utilizzata per la connettività privata al producer. Le dimensioni della subnet possono essere ridotte: il NEG PSC richiede solo un IP dalla subnet. Per Apigee, è necessario un solo NEG PSC per regione. La subnet può essere condivisa e utilizzata dalle VM o da altre entità. Se non viene specificata una subnet, gli endpoint di rete possono appartenere a qualsiasi subnet nella regione in cui viene creato il gruppo di endpoint di rete.
  Nota: se specifichi il parametro --network,devi specificare anche --subnet.
- $PROJECT_ID Il progetto Cloud già associato alla tua organizzazione Apigee o un progetto Cloud incluso in consumerAcceptlist al momento della creazione dell'istanza di runtime Apigee. Se non l'hai già fatto, crea una variabile di ambiente che contenga l'ID progetto, perché viene utilizzato nella maggior parte dei seguenti comandi.

Prenota un indirizzo IPv4 esterno globale per il bilanciatore del carico.

gcloud compute addresses create ADDRESS_NAME \
    --ip-version=IPV4 --global --project=$PROJECT_ID

Sostituisci ADDRESS_NAME con un nome per la risorsa dell'indirizzo IP.

Esegui questo comando per visualizzare l'indirizzo IP riservato:

gcloud compute addresses describe ADDRESS_NAME \
    --format="get(address)" --global --project=$PROJECT_ID

Crea un servizio di backend per il NEG.

gcloud compute backend-services create BACKEND_SERVICE_NAME \
    --load-balancing-scheme=EXTERNAL_MANAGED \
    --protocol=HTTPS \
    --global --project=$PROJECT_ID

Sostituisci BACKEND_SERVICE_NAME con il nome del servizio di backend.

Aggiungi il servizio di backend al NEG.
```
gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
    --network-endpoint-group=NEG_NAME \
    --network-endpoint-group-region=REGION \
    --global --project=$PROJECT_ID
```
Sostituisci quanto segue:
- BACKEND_SERVICE_NAME: il nome del servizio di backend.
- NEG_NAME: il nome del gruppo di endpoint di rete.
- REGION: la regione del gruppo di endpoint di rete.
Crea una mappa URL per il bilanciatore del carico.

Una mappa URL deve fare riferimento a un servizio di backend predefinito. Imposta come predefinito il servizio di backend che hai appena creato.
```
gcloud compute url-maps create URL_MAP_NAME \
    --default-service=DEFAULT_BACKEND_SERVICE_NAME \
    --global --project=$PROJECT_ID
```
Sostituisci quanto segue:
- URL_MAP_NAME: un nome per la mappa URL.
- DEFAULT_BACKEND_SERVICE_NAME: il nome del servizio di backend predefinito del bilanciatore del carico. L'impostazione predefinita viene utilizzata quando nessuna regola host corrisponde al nome host richiesto.
Crea il proxy HTTPS di destinazione.

Per creare un bilanciatore del carico HTTPS, devi disporre di una risorsa del certificato SSL da utilizzare nel proxy di destinazione HTTPS. Puoi creare una risorsa del certificato SSL utilizzando un certificato SSL gestito da Google o un certificato SSL autogestito. Ti consigliamo di utilizzare i certificati gestiti da Google perché Google Cloud li ottiene, gestisce e rinnova automaticamente.

Per creare un certificato gestito da Google, devi avere un dominio.

Utilizza questo comando per creare una risorsa del certificato SSL gestito da Google:
```
gcloud compute ssl-certificates create CERTIFICATE \
    --domains DOMAIN --project=$PROJECT_ID
```
Sostituisci quanto segue:
- CERTIFICATE: un nome per il certificato.
- DOMAIN: il nome di dominio del bilanciatore del carico.
Utilizza questo comando per creare una risorsa del certificato SSL autogestito. Per creare un certificato SSL autogestito, sono necessari un file di chiave privata locale e un file di certificato locale. Se devi creare questi file, consulta il passaggio 1 sull'utilizzo dei certificati SSL autogestiti.
```
gcloud compute ssl-certificates create CERTIFICATE \
    --certificate LB_CERT \
    --private-key LB_PRIVATE_KEY --project=$PROJECT_ID
```
Sostituisci quanto segue:
- CERTIFICATE: un nome per il certificato.
- LB_CERT: il percorso del file del certificato in formato PEM per il certificato autogestito.
- LB_PRIVATE_KEY: il percorso del file della chiave privata in formato PEM per il certificato autogestito.
Utilizza la risorsa del certificato SSL per creare un proxy HTTPS di destinazione.
```
gcloud compute target-https-proxies create PROXY_NAME \
    --url-map=URL_MAP_NAME \
    --ssl-certificates=CERTIFICATE --project=$PROJECT_ID
```
Sostituisci quanto segue:
- PROXY_NAME: un nome per il proxy HTTPS di destinazione.
- URL_MAP_NAME: il nome della mappa URL.
- CERTIFICATE: il nome della risorsa del certificato.
Crea la regola di forwarding.
```
gcloud compute forwarding-rules create FWD_RULE \
    --load-balancing-scheme=EXTERNAL_MANAGED \
    --network-tier=PREMIUM \
    --address=ADDRESS_NAME \
    --target-https-proxy=PROXY_NAME \
    --ports=443 \
    --global --project=$PROJECT_ID
```
Sostituisci quanto segue:
- FWD_RULE: un nome per la regola di forwarding.
- ADDRESS_NAME: la risorsa dell'indirizzo IP che hai prenotato per l'utilizzo per la regola di forwarding.
- PROXY_NAME: il nome del proxy HTTPS di destinazione.

Bilanciatore del carico esterno regionale

Configura un bilanciatore del carico HTTP(S) esterno regionale. Vedi anche Panoramica dei bilanciatori del carico HTTP(S) esterni.

Assicurati di aver impostato le variabili in Definisci le variabili di ambiente.
Crea una subnet solo proxy:
Nota : questa operazione deve essere eseguita una sola volta. Questa subnet solo proxy è richiesta solo una volta per progetto Google Cloud per qualsiasi bilanciatore del carico a livello di regione basato su Envoy. Vedi anche Subnet solo proxy per bilanciatori del carico basati su Envoy.
```
gcloud compute networks subnets create SUBNET_NAME \
      --purpose=REGIONAL_MANAGED_PROXY --role=ACTIVE \
      --region=$RUNTIME_LOCATION --network=NETWORK_NAME \
      --range=100.0.0.0/24 --project=$PROJECT_ID
```
Sostituisci quanto segue:
- SUBNET_NAME: il nome della subnet.
- (Facoltativo) NETWORK_NAME: nome della rete in cui viene creata la subnet. Se ometti questo parametro, viene utilizzata la rete di progetto predefinita.

Recupera il collegamento al servizio dall'istanza creata in precedenza:

Nessuna residenza dei dati

curl -i -X GET -H "Authorization: Bearer $AUTH" \
    "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances"

Residenza dei dati

curl -i -X GET -H "Authorization: Bearer $AUTH" \
    "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances"

Nel seguente output di esempio, il valore serviceAttachment è mostrato in grassetto:

{
  "instances": [
    {
      "name": "us-west1",
      "location": "us-west1",
      "host": "10.82.192.2",
      "port": "443",
      "createdAt": "1645731488019",
      "lastModifiedAt": "1646504754219",
      "diskEncryptionKeyName": "projects/my-project/locations/us-west1/keyRings/us-west1/cryptoKeys/dek",
      "state": "ACTIVE",
      "peeringCidrRange": "SLASH_22",
      "runtimeVersion": "1-7-0-20220228-190814",
      "ipRange": "10.82.192.0/22,10.82.196.0/28",
      "consumerAcceptList": [
        "875609189304"
      ],
      "serviceAttachment": "projects/bfac7497a40c32a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw7"
    }
  ]
}

Crea un gruppo di endpoint di rete.
```
gcloud compute network-endpoint-groups create NEG_NAME \
    --network-endpoint-type=private-service-connect \
    --psc-target-service=TARGET_SERVICE \
    --region=$RUNTIME_LOCATION --project=$PROJECT_ID
```
Sostituisci quanto segue:
- NEG_NAME: il nome del gruppo di endpoint di rete.
- TARGET_SERVICE: il nome del collegamento al servizio a cui vuoi connetterti. Ad esempio: projects/bfac7497a40c32a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw7

Crea un servizio di backend per il NEG.

gcloud compute backend-services create BACKEND_SERVICE_NAME \
  --load-balancing-scheme=EXTERNAL_MANAGED \
  --protocol=HTTPS \
  --region=$RUNTIME_LOCATION  \
  --project=$PROJECT_ID

Sostituisci BACKEND_SERVICE_NAME con il nome del servizio di backend.

Aggiungi il servizio di backend al NEG.
```
gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
  --network-endpoint-group=NEG_NAME \
  --region=$RUNTIME_LOCATION  \
  --project=$PROJECT_ID
```
Sostituisci quanto segue:
- BACKEND_SERVICE_NAME: il nome del servizio di backend.
- NEG_NAME: il nome del gruppo di endpoint di rete.
Crea una mappa URL per il bilanciatore del carico.

Una mappa URL deve fare riferimento a un servizio di backend predefinito. Imposta come predefinito il servizio di backend che hai appena creato.
```
gcloud compute url-maps create URL_MAP_NAME \
  --default-service=DEFAULT_BACKEND_SERVICE_NAME \
  --region=$RUNTIME_LOCATION  \
  --project=$PROJECT_ID
```
Sostituisci quanto segue:
- URL_MAP_NAME: un nome per la mappa URL.
- DEFAULT_BACKEND_SERVICE_NAME: il nome del servizio di backend predefinito del bilanciatore del carico. L'impostazione predefinita viene utilizzata quando nessuna regola host corrisponde al nome host richiesto.
Crea il proxy HTTPS di destinazione.

Per creare un bilanciatore del carico HTTPS, devi disporre di una risorsa del certificato SSL da utilizzare nel proxy di destinazione HTTPS.

Utilizza questo comando per creare una risorsa del certificato SSL autogestito. Per creare un certificato SSL autogestito, sono necessari un file di chiave privata locale e un file di certificato locale. Se devi creare questi file, consulta il passaggio 1 sull'utilizzo dei certificati SSL autogestiti.

Nota: i certificati gestiti da Google non sono supportati dal bilanciatore del carico a livello di regione interno.
```
gcloud compute ssl-certificates create CERTIFICATE \
  --certificate LB_CERT \
  --private-key LB_PRIVATE_KEY --region=$RUNTIME_LOCATION \
  --project=$PROJECT_ID
```
Sostituisci quanto segue:
- CERTIFICATE: un nome per il certificato.
- LB_CERT: il percorso del file del certificato in formato PEM per il certificato autogestito.
- LB_PRIVATE_KEY: il percorso del file della chiave privata in formato PEM per il certificato autogestito.
Utilizza la risorsa del certificato SSL per creare un proxy HTTPS di destinazione.
```
gcloud compute target-https-proxies create PROXY_NAME \
  --url-map=URL_MAP_NAME --region=$RUNTIME_LOCATION \
  --ssl-certificates=CERTIFICATE --project=$PROJECT_ID
```
Sostituisci quanto segue:
- PROXY_NAME: un nome per il proxy HTTPS di destinazione.
- URL_MAP_NAME: il nome della mappa URL.
- CERTIFICATE: il nome della risorsa del certificato.

Prenota un indirizzo esterno regionale per il bilanciatore del carico. Tieni presente che il livello di rete deve essere impostato su STANDARD.

gcloud compute addresses create ADDRESS_NAME \
      --region=$RUNTIME_LOCATION --network-tier=STANDARD \
      --project=$PROJECT_ID

Sostituisci ADDRESS_NAME con un nome per la risorsa dell'indirizzo IP.

Esegui questo comando per visualizzare l'indirizzo IP riservato:

gcloud compute addresses describe ADDRESS_NAME \
      --format="get(address)" --region=$RUNTIME_LOCATION \
      --project=$PROJECT_ID

Crea la regola di forwarding.

gcloud compute forwarding-rules create FWD_RULE \
  --load-balancing-scheme=EXTERNAL_MANAGED \
  --network-tier=STANDARD \
  --address=ADDRESS_NAME \
  --target-https-proxy=PROXY_NAME \
  --ports=443  --region=$RUNTIME_LOCATION \
  --target-https-proxy-region=$RUNTIME_LOCATION --project=$PROJECT_ID

Sostituisci quanto segue:

FWD_RULE: un nome per la regola di forwarding.
ADDRESS_NAME: la risorsa dell'indirizzo IP che hai prenotato per l'utilizzo per la regola di forwarding.
PROXY_NAME: il nome del proxy HTTPS di destinazione.

Provisioning di Apigee completato. Vai a Deployment di un proxy di esempio.

Passaggio 8: deployment di un proxy di esempio

Autorizzazioni richieste per questa attività

La creazione e il deployment dei proxy richiede un insieme minimo di autorizzazioni. Se hai il ruolo di amministratore organizzazione Apigee, puoi completare questa attività. Per scoprire di più sugli altri ruoli che puoi utilizzare, consulta Ruoli Apigee.

Scarica il proxy di esempio da GitHub. La destinazione del proxy è il servizio httpbin.org, un servizio pubblico di richiesta e risposta di uso comune.

Carica il bundle proxy API nel runtime utilizzando l'API Apigee apis:

Nessuna residenza dei dati

curl -i -X POST -H "Authorization: Bearer $AUTH" \
    -H "Content-Type:multipart/form-data" \
    "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/apis?name=httpbin&action=import" \
    -F 'file=@PATH_TO_ZIP_FILE/httpbin_rev1_2020_02_02.zip'

Residenza dei dati

curl -i -X POST -H "Authorization: Bearer $AUTH" \
    -H "Content-Type:multipart/form-data" \
    "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/apis?name=httpbin&action=import" \
    -F 'file=@PATH_TO_ZIP_FILE/httpbin_rev1_2020_02_02.zip'

Dove PATH_TO_ZIP_FILE è il percorso della directory contenente il file ZIP scaricato.

Esegui il deployment del proxy API nell'ambiente creato in precedenza:

Nessuna residenza dei dati

curl -i -H "Authorization: Bearer $AUTH" -X POST \
    "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments/$ENVIRONMENT_NAME/apis/httpbin/revisions/1/deployments"

Residenza dei dati

curl -i -H "Authorization: Bearer $AUTH" -X POST \
    "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments/$ENVIRONMENT_NAME/apis/httpbin/revisions/1/deployments"

Conferma che il deployment sia stato completato correttamente con questa chiamata API:

Nessuna residenza dei dati

curl -i -H "Authorization: Bearer $AUTH" \
    "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments/$ENVIRONMENT_NAME/apis/httpbin/revisions/1/deployments"

Residenza dei dati

curl -i -H "Authorization: Bearer $AUTH" \
    "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments/$ENVIRONMENT_NAME/apis/httpbin/revisions/1/deployments"

Chiama il proxy API:

Invia una richiesta al proxy API da qualsiasi macchina abilitata in rete eseguendo questo comando:

curl -i -H "Host: ENV_GROUP_HOSTNAME" \
    "https://ENV_GROUP_HOSTNAME/httpbin/headers"

Se necessario, puoi utilizzare questa API per ottenere il valore ENV_GROUP_HOSTNAME:

Nessuna residenza dei dati

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

Residenza dei dati

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

Se ricevi un errore come questo: CONNECT_CR_SRVR_HELLO:sslv3 alert handshake failure, verifica che sia stato eseguito il provisioning del certificato SSL che hai creato in precedenza. Utilizza questo comando per controllare lo stato del provisioning. Dopo il provisioning del certificato, il suo stato è ACTIVE.

gcloud compute ssl-certificates describe CERTIFICATE \
    --global \
    --format="get(name,managed.status, managed.Status)"

Se l'operazione riesce, il proxy API di esempio restituisce una risposta simile alla seguente:

{
    "headers": {
      "Accept": "*/*",
      "Grpc-Trace-Bin": "AAD/8WC/I4AUSrMEch0E9yj+AYck1x9afwckAgA",
      "Host": "httpbin.org",
      "Traceparent": "00-fff160bf2380144ab304721d04f728fe-8724d71f5a7f0724-00",
      "User-Agent": "curl/7.77.0",
      "X-Amzn-Trace-Id": "Root=1-61d785ef-7613aa8a7fde7a910441fab9",
      "X-B3-Sampled": "0",
      "X-B3-Spanid": "8724d71f5a7f0724",
      "X-B3-Traceid": "fff160bf2380144ab304721d04f728fe",
      "X-Cloud-Trace-Context": "fff160bf2380144ab304721d04f728fe/9738144823944087332;o=0",
      "X-Envoy-Attempt-Count": "1"
    }
}

Per ulteriori informazioni sul deployment dei proxy, incluse ulteriori informazioni sulla risoluzione dei problemi, consulta Deployment di un proxy API.

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

Limitazioni

Riepilogo dei passaggi

Passaggio 1: definizione delle variabili di ambiente

Nessuna residenza dei dati

Residenza dei dati

Nessuna residenza dei dati

Residenza dei dati

Passaggio 2: attivazione delle API

Autorizzazioni richieste per questa attività

Passaggio 3: crea l'identità del servizio Apigee

Passaggio 4: creazione di un'organizzazione

Autorizzazioni richieste per questa attività

Regione singola

Più regioni

Nessuna residenza dei dati

Residenza dei dati

Nessuna residenza dei dati

Residenza dei dati

Passaggio 5: creazione di un'istanza di runtime

Autorizzazioni richieste per questa attività

Nessuna residenza dei dati

Residenza dei dati

Nessuna residenza dei dati

Residenza dei dati

Nessuna residenza dei dati

Residenza dei dati

Passaggio 6: creazione di un ambiente

Autorizzazioni richieste per questa attività

Abbonamento

Pay-as-you-go

Abbonamento

Nessuna residenza dei dati

Residenza dei dati

Pay-as-you-go

Nessuna residenza dei dati

Residenza dei dati

Nessuna residenza dei dati

Residenza dei dati

Nessuna residenza dei dati

Residenza dei dati

Nessuna residenza dei dati

Residenza dei dati

Nessuna residenza dei dati

Residenza dei dati

Nessuna residenza dei dati

Residenza dei dati

Nessuna residenza dei dati

Residenza dei dati

Nessuna residenza dei dati

Residenza dei dati

Passaggio 7: configurazione del routing

Routing interno (PSC)

Endpoint di servizio

Autorizzazioni richieste per questa attività

Crea un endpoint di servizio PSC per il collegamento al servizio

Nessuna residenza dei dati

Residenza dei dati

Bilanciatore del carico regionale interno

Autorizzazioni richieste per questa attività

Passaggio 8a: configura le variabili di ambiente

Passaggio 8b: crea una subnet solo proxy

Passaggio 8c: crea un gruppo di endpoint di rete (NEG)

Nessuna residenza dei dati

Residenza dei dati

Passaggio 8d: configura il bilanciatore del carico interno a livello di regione

Routing esterno (PSC)

Autorizzazioni richieste per questa attività

Passaggio 8b: crea un NEG e configura il bilanciatore del carico

Bilanciatore del carico esterno globale

Nessuna residenza dei dati

Residenza dei dati

Bilanciatore del carico esterno regionale

Nessuna residenza dei dati

Residenza dei dati

Passaggio 8: deployment di un proxy di esempio

Autorizzazioni richieste per questa attività

Nessuna residenza dei dati

Residenza dei dati

Nessuna residenza dei dati