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

Questa pagina si applica ad Apigee, ma non ad Apigee hybrid.

Visualizza la documentazione di Apigee Edge.

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

Vedi anche Opzioni di provisioning.

Limitazioni

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

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

Riepilogo dei passaggi

I passaggi di 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 completato i requisiti di configurazione elencati in Prima di iniziare.
  2. Devi aver installato Cloud SDK. Se devi installarlo, consulta Installazione di Cloud SDK.
  3. Inizializza Cloud SDK, come descritto in Inizializzare gcloud CLI, o assicurati che il progetto Google Cloud che hai creato in Prerequisiti sia il progetto predefinito per gcloud.
  4. Definisci le seguenti variabili di ambiente nel terminale dei comandi. Seleziona la scheda corrispondente al tipo di organizzazione che ti serve: 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 connessione. Utilizzerai questa intestazione quando chiami le API Apigee. Tieni presente che il token scade dopo un periodo di tempo e, quando ciò accade, puoi rigenerarlo semplicemente utilizzando lo stesso comando. Per maggiori informazioni, consulta la pagina di riferimento per il comando 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 un secondo momento. Per un elenco delle località di runtime disponibili, consulta Località Apigee.

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

      RUNTIME_LOCATION e 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 questa intestazione quando chiami le API Apigee. Tieni presente che il token scade dopo un periodo di tempo e, quando ciò accade, puoi rigenerarlo semplicemente utilizzando lo stesso comando. Per maggiori informazioni, consulta la pagina di riferimento per il comando 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 un secondo momento. Per un elenco delle località di runtime disponibili, consulta Località Apigee.

      La posizione di runtime deve trovarsi all'interno della posizione del control plane.
    • CONTROL_PLANE_LOCATION è la posizione fisica in cui verranno archiviati i dati del control plane Apigee. Per un elenco delle località del control plane disponibili, consulta Località Apigee.
    • CONSUMER_DATA_REGION è una sottoregione della regione del control plane. Devi specificare sia CONTROL_PLANE_LOCATION sia 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:

  5. (Facoltativo) Controlla il tuo lavoro ripetendo i valori che hai appena impostato. Tieni presente che quando vuoi utilizzare una variabile nei comandi, anteponi al nome della variabile il 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 comandi echo dovrebbero essere simili alle seguenti:

    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. Abilitali eseguendo questo comando services enable:

    gcloud services enable apigee.googleapis.com \
    apihub.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 abilitato.

Passaggio 3: crea l'identità di servizio Apigee

  1. Crea l'identità di servizio Apigee:

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

  2. Verifica che l'agente sia stato creato correttamente. La risposta deve 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

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

  1. Crea una chiave automatizzata 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, quando li crei, garantisci la coerenza e ti sarà più facile seguire la documentazione.

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

      Regione singola

      Configurazioni a regione singola (in cui hai una sola istanza in una regione): scegli tra le posizioni regionali KMS supportate.

      Ad esempio:

      RUNTIMEDBKEY_LOCATION="us-west1"

      Il valore può essere uguale a $RUNTIME_LOCATION (anch'essa una regione), ma non è obbligatorio. Tuttavia, se sono uguali, le prestazioni potrebbero migliorare.

      Più regioni

      Configurazioni multiregionali:scegli tra le località multiregionali supportate (ad esempio us o europe) o le località a due regioni.

      Ad esempio:

      RUNTIMEDBKEY_LOCATION="us"

      Se hai una configurazione multiregionale negli Stati Uniti, ti consigliamo di utilizzare us per la tua posizione, se possibile. Altrimenti, utilizza 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 una seconda o successiva regione, il nome non può essere uguale a quello di altri portachiavi.

      RUNTIMEDB_KEY_RING_NAME=YOUR_DB_KEY_RING_NAME
RUNTIMEDB_KEY_NAME=YOUR_DB_KEY_NAME
    3. (Facoltativo) Controlla il tuo lavoro ripetendo i valori che hai appena impostato. Ricorda che quando vuoi utilizzare una variabile nei comandi, anteponi al nome della variabile il 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 posizione della chiave di crittografia del database di runtime di Apigee supporta tutte le posizioni 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.

      Al termine della richiesta, gcloud risponde con un risultato 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 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 del account di servizio.

  2. Se utilizzi la residenza dei dati, crea un portachiavi e una chiave di crittografia del control plane. Se non utilizzi la residenza dei dati, vai al passaggio 3.

    3. Esegui i seguenti passaggi per creare una chiave automatizzata e una chiave di crittografia del control plane.

    1. Definisci una variabile di ambiente per la posizione dell'anello 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 control plane Apigee. Per un elenco delle località del control plane disponibili, consulta Località Apigee.
      • CONSUMER_DATA_REGION è una sottoregione della regione del control plane. 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 portachiavi e i nomi delle chiavi del database del control plane.

      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 delle chiavi automatizzate che utilizzerai per identificare le chiavi automatizzate di crittografia del control plane.
      • CONTROL_PLANE_KEY_NAME è il nome della chiave che utilizzerai per identificare la chiave di crittografia del control plane.
      • CONSUMER_DATA_KEY_RING_NAME è il nome delle chiavi automatizzate che utilizzerai per identificare le chiavi automatizzate di crittografia della regione dei dati dei consumatori.
      • CONSUMER_DATA_KEY_NAME è il nome della chiave che utilizzerai per identificare la chiave di crittografia della regione dei dati dei consumatori.
    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 della 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 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 del service 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"'",
    "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 tua nuova organizzazione. Deve avere lo stesso nome dell'ID progetto.

      • analyticsRegion: specifica la posizione fisica in cui verranno archiviati i dati di Analytics.

      • 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. Valore predefinito: false
      • 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"'",
    "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 tua nuova organizzazione. Deve avere lo stesso nome dell'ID progetto.
    • runtimeType: imposta questo valore su CLOUD.
    • billingType: specifica il tipo di fatturazione dell'organizzazione creata.
    • controlPlaneEncryptionKeyName: è l'ID della chiave del control plane.
    • apiConsumerDataLocation: Devi anche specificare una regione secondaria da utilizzare per le risorse interne. Consulta Regioni di residenza dei dati per i valori supportati.
    • apiConsumerDataEncryptionKeyName: è l'ID della chiave della regione dei dati dei consumatori.
    • disableVpcPeering: imposta su true se non vuoi utilizzare il peering VPC. Valore predefinito: false
    • 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, il cui completamento può richiedere alcuni minuti.

    Se ricevi un errore, controlla l'utilizzo delle virgolette intorno ai valori delle variabili nel payload dei dati. Assicurati di avere virgolette doppie-singole-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 racchiuderle tra virgolette doppie all'interno della stringa del payload tra virgolette singole, come mostrato nell'esempio seguente:

    '{ "name":"my-gcp-project", ... }'
  4. Attendi qualche minuto.
  5. Per controllare lo stato della richiesta di creazione, puoi inviare una richiesta GET all'API List organizations di Apigee, 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"
  }
}

    In caso di esito positivo, l'oggetto risposta indicherà "state": "ACTIVE" e potrai passare al passaggio successivo.

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

Passaggio 5: creazione di un'istanza di runtime

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

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

    Per farlo, invia la seguente richiesta all'API Organizations:

    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 con i relativi dettagli. Se Apigee risponde con un errore, attendi un paio di minuti e invia nuovamente la richiesta.

  2. 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 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

    3. 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 contenere almeno due caratteri.
    • RUNTIME_LOCATION è la posizione fisica in cui è ospitato il cluster. I valori validi sono qualsiasi località consentita da Compute Engine. (vedi Regioni e zone disponibili). Questo esempio utilizza us-west1.
    • DISK_KEY_RING_NAME è il nome delle chiavi automatizzate di crittografia del disco.
    • DISK_KEY_NAME è il nome della chiave di crittografia del disco.
  3. Crea una chiave di crittografia del disco:
    1. Crea un nuovo portachiavi del disco: 
      gcloud kms keyrings create $DISK_KEY_RING_NAME \
  --location $RUNTIME_LOCATION \
  --project $PROJECT_ID

      Il keyring del disco deve essere impostato sulla stessa località dell'istanza. Ogni istanza e portachiavi deve avere la propria posizione.

    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 relativo 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 chiave ha il seguente aspetto:

      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 saperne di più, vedi Informazioni sulle chiavi di crittografia Apigee.

  4. 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 all' service attachment del VPC Apigee. Il collegamento del 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 nell'interfaccia utente dell'istanza. Per maggiori dettagli, vedi 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 questo cluster e configurare il bilanciamento del carico.

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

  5. Per controllare lo stato della richiesta di creazione dell'istanza di runtime, esegui il comando seguente. Quando lo stato è ATTIVO, puoi passare 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

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

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

    Abbonamento

    Per un ambiente di 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

    Pagamento a consumo

    Per un ambiente Pay as you go, 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 con 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
  2. Crea un nuovo ambiente con l'API Environments. I comandi specifici che utilizzi dipendono dal fatto che tu stia creando un ambiente per un'organizzazione con abbonamento o pagamento a consumo.

    Abbonamento

    Per un nuovo ambiente di abbonamento, 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"'"
  }'

    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.

    Pagamento a consumo

    Per un nuovo ambiente Pay as you go, 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.

  3. Prima di continuare, verifica che Apigee abbia terminato la creazione del 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 degli ambienti disponibili. Ad esempio, se il nome dell'ambiente è test, Apigee risponde con quanto segue:

    [
  "test"
]
  4. 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 vedi un output come il seguente, puoi passare al passaggio successivo: 

    {
  "attachments": [
    {
      "name": "ed628782-c893-4095-b71c-f4731805290a",
      "environment": "test",
      "createdAt": "1641604447542"
    }
  ]
}
  5. Crea un nuovo gruppo di ambienti utilizzando il seguente comando. Per maggiori informazioni, vedi Informazioni su ambienti e 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"'"]
  }'
  6. Attendi il completamento dell'operazione. Puoi controllare lo stato del 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"
  7. Collega il nuovo ambiente al nuovo gruppo di ambienti con questo 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"'"
  }'
  8. 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, configuri il modo in cui le applicazioni client comunicano con Apigee. Il traffico da client ad Apigee è chiamato anche traffico "inbound". Le opzioni di configurazione in direzione nord includono quanto segue. Vai all'opzione di configurazione che vuoi utilizzare ed esegui i passaggi per questa opzione:

Tipo di accesso Descrizione della procedura di configurazione e deployment
Interno con PSC (novità)

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

PSC consente 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 che controlli). Con questo metodo, le richieste passano attraverso un endpoint di servizio o un bilanciatore del carico interno regionale a un unico punto di collegamento, chiamato collegamento del servizio. Questa configurazione consente ai client interni di inviare richieste proxy API Apigee da qualsiasi macchina abilitata alla rete.
Esterno con PSC (novità)

Consenti l'accesso esterno ai tuoi 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 consumatore di servizi (il progetto VPC in peering e/o uno o più altri progetti cloud che controlli). Con questo metodo, le richieste passano attraverso un bilanciatore del carico esterno globale o un bilanciatore del carico esterno regionale a un unico punto di collegamento, chiamato collegamento del servizio. Questa configurazione ti consente di inviare richieste proxy API Apigee da qualsiasi macchina abilitata alla rete.

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

Routing interno (PSC)

Questa sezione spiega come consentire 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:

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

Endpoint di servizio

Crea un endpoint di servizio PSC per il collegamento del servizio

  1. Recupera l'allegato di servizio dall'istanza che hai creato 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"
    }
  ]
}
  2. Crea un endpoint di servizio PSC che rimandi al collegamento al servizio ottenuto dal corpo della risposta dell'istanza nel passaggio precedente, come spiegato in Creare un endpoint Private Service Connect.
  3. Il provisioning di Apigee è completato. Vai a Deployment di un proxy di esempio.

Bilanciatore del carico interno regionale

Passaggio 7a: configura le variabili di ambiente

Le istruzioni riportate in questa sezione utilizzano le variabili di ambiente per fare riferimento a stringhe utilizzate ripetutamente. Assicurati di aver impostato le variabili in Definisci le variabili di ambiente.

Inoltre, imposta le seguenti variabili di ambiente:

NEG_NAME=YOUR_NEG_NAME
  NETWORK_NAME=YOUR_NETWORK_NAME
  SUBNET_NAME=YOUR_SUBNET_NAME
  TARGET_SERVICE=TARGET_SERVICE_ATTACHMENT

Dove:

  • NEG_NAME: un nome per il gruppo di endpoint di rete.
  • NETWORK_NAME: (facoltativo) il 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. La dimensione della subnet può essere ridotta: il NEG PSC ha bisogno di un solo IP dalla subnet. Per Apigee, è necessario un solo NEG PSC per regione. La subnet può essere condivisa e utilizzata da VM o 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.
  • TARGET_SERVICE: l'allegato del servizio a cui vuoi connetterti. Ad esempio: projects/bfac7497a40c32a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw7

Passaggio 7b: 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 7c: crea un gruppo di endpoint di rete (NEG)

  1. Recupera l'allegato di servizio dall'istanza che hai creato 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"
    }
  ]
  }

  2. Crea un NEG Private Service Connect che rimandi al collegamento di servizio che hai 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
--network=$NETWORK_NAME
--subnet=$SUBNET_NAME

    Dove

    • $PROJECT_ID può essere il progetto Cloud già associato alla tua organizzazione Apigee o un progetto Cloud incluso in consumerAcceptlist quando è stata creata l'istanza di runtime Apigee.

Passaggio 7d: configura il bilanciatore del carico interno regionale

  1. 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
  2. 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_LOCATION \
--project=$PROJECT_ID

    3. Sostituisci BACKEND_SERVICE_NAME con il nome del servizio di backend.

  3. Aggiungi il NEG al servizio di backend: 
    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.

  4. 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, devi disporre di un file di chiave privata locale e di un file di certificato locale. Se devi creare questi file, consulta il passaggio 1 dell'utilizzo dei certificati SSL autogestiti.

    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.

  5. Crea una mappa URL per il bilanciatore del carico.

    Una mappa URL deve fare riferimento a un servizio di backend predefinito. Imposta il servizio di backend che hai appena creato come predefinito.

    gcloud compute url-maps create URL_MAP_NAME \
--default-service=DEFAULT_BACKEND_SERVICE_NAME \
--region=$RUNTIME_REGION \
--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.

  6. 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 certificato.
  7. 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 \
--network=$NETWORK_NAME \
--subnet=$SUBNET_NAME

    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 con la regola di forwarding.
    • PROXY_NAME: il nome del proxy HTTPS di destinazione.
    • NETWORK_NAME: (facoltativo) il 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.
  8. Il 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 Apigee Runtime.

Passaggio 7b: 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).

Sebbene il NEG Private Service Connect sia regionale, tutti gli altri componenti di bilanciamento del carico in questa configurazione sono globali.

  1. Assicurati di aver impostato le variabili di ambiente in Definisci le variabili di ambiente.
  2. Recupera l'allegato di servizio dall'istanza che hai creato 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"
    }
  ]
}

  3. Crea un NEG Private Service Connect che rimandi al collegamento di servizio che hai 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 service attachment a cui vuoi connetterti. Utilizza il valore dell'allegato di servizio restituito dal comando precedente. Ad esempio: projects/bfac7497a40c32a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw7
    • NETWORK_NAME: (facoltativo) Il nome della rete in cui viene creato il NEG. Se ometti questo parametro, viene utilizzata la rete del progetto default.
    • SUBNET_NAME: il nome della subnet utilizzata per la connettività privata al produttore. La dimensione della subnet può essere ridotta: il NEG PSC ha bisogno di un solo IP dalla subnet. Per Apigee, è necessario un solo NEG PSC per regione. La subnet può essere condivisa e utilizzata da VM o 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.
    • $PROJECT_ID Il progetto Cloud già associato alla tua organizzazione Apigee o un progetto Cloud incluso in consumerAcceptlist quando è stata creata l'istanza di runtime Apigee. Se non l'hai ancora fatto, crea una variabile di ambiente per contenere l'ID progetto, perché viene utilizzato nella maggior parte dei comandi seguenti.
  4. 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
  5. 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

    6. Sostituisci BACKEND_SERVICE_NAME con il nome del servizio di backend.

  6. Aggiungi il NEG al servizio di backend. 
    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.

  7. Crea una mappa URL per il bilanciatore del carico.

    Una mappa URL deve fare riferimento a un servizio di backend predefinito. Imposta il servizio di backend che hai appena creato come predefinito.

    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.

  8. Crea il proxy HTTPS di destinazione.

    Per creare un bilanciatore del carico HTTPS, devi disporre di una risorsa 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. L'utilizzo di certificati gestiti da Google è consigliato 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, devi disporre di un file della chiave privata locale e di un file del certificato locale. Se devi creare questi file, consulta il passaggio 1 dell'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 certificato.
  9. 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 con 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 del bilanciatore del carico HTTP(S) esterno.

  1. Assicurati di aver impostato le variabili in Definisci le variabili di ambiente.
  2. Crea una subnet solo proxy: 
    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 del progetto predefinita.
  3. Recupera l'allegato di servizio dall'istanza che hai creato 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"
    }
  ]
}
  4. 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 service attachment a cui vuoi connetterti. Ad esempio: projects/bfac7497a40c32a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw7
  5. 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

    6. Sostituisci BACKEND_SERVICE_NAME con il nome del servizio di backend.

  6. Aggiungi il NEG al servizio di backend. 
    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.

  7. Crea una mappa URL per il bilanciatore del carico.

    Una mappa URL deve fare riferimento a un servizio di backend predefinito. Imposta il servizio di backend che hai appena creato come predefinito.

    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.

  8. Crea il proxy HTTPS di destinazione.

    Per creare un bilanciatore del carico HTTPS, devi disporre di una risorsa 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, devi disporre di un file della chiave privata locale e di un file del certificato locale. Se devi creare questi file, consulta il passaggio 1 dell'utilizzo dei certificati SSL autogestiti.

    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 certificato.
  9. 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
  10. 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 con la regola di forwarding.
    • PROXY_NAME: il nome del proxy HTTPS di destinazione.

Il provisioning di Apigee è completato. Vai a Deployment di un proxy di esempio.

Passaggio 8: deployment di un proxy di esempio

  1. Scarica il proxy di esempio da GitHub. Il target del proxy è il servizio httpbin.org, che è un servizio pubblico di richiesta e risposta di uso comune.
  2. Carica il bundle di 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.

  3. Esegui il deployment del proxy API nell'ambiente che hai 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"
  4. Verifica 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"

  5. Chiama il proxy API:

    Invia una richiesta al proxy API da qualsiasi macchina abilitata alla rete eseguendo il comando seguente:

    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, controlla che il certificato SSL che hai creato in precedenza sia stato sottoposto a provisioning. Utilizza questo comando per controllare lo stato del provisioning. Quando il certificato viene sottoposto a provisioning, il relativo stato è ACTIVE. 

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

    In caso di esito positivo, il proxy API di esempio restituisce una risposta simile a questa: 

    {
    "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 maggiori informazioni sul deployment dei proxy, incluse informazioni aggiuntive per la risoluzione dei problemi, consulta Deployment di un proxy API.