Installa l'operatore APIM di Apigee per Kubernetes

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

Visualizza la documentazione di Apigee Edge.

Questa pagina descrive i passaggi necessari per installare e configurare l'operatore Apigee APIM per Kubernetes. Per saperne di più sui vantaggi dell'utilizzo dell'operatore APIM, consulta Panoramica dell'operatore APIM Apigee per Kubernetes.

Prima di iniziare

Prima di iniziare l'installazione dell'operatore APIM, assicurati di disporre dei ruoli e delle autorizzazioni necessari per completare i passaggi e di aver completato le attività preliminari descritte in Operatore APIM: prima di iniziare.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per installare l'operatore APIM, chiedi all'amministratore di concederti i seguenti ruoli IAM nell'organizzazione:

• Crea e gestisci il cluster GKE: Container Admin (roles/container.admin)
• Crea e gestisci service account: Amministratore service account (roles/iam.serviceAccountAdmin)
• Crea e gestisci le estensioni di servizio: Service Extensions Admin (roles/networkservices.serviceExtensionsAdmin)
• Crea e gestisci gruppi di endpoint di rete (NEG): Compute Instance Admin (roles/compute.instanceAdmin)
• Crea e gestisci i servizi di backend: Amministratore bilanciatore del carico Compute (roles/compute.loadBalancerAdmin)
• Crea e gestisci risorse Apigee: Apigee Admin (roles/apigee.admin)

Per ulteriori informazioni sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Installa e configura l'operatore APIM

Le sezioni seguenti descrivono i passaggi necessari per installare e configurare l'operatore APIM:

1. Imposta le variabili di ambiente.
2. Abilita le API richieste.
3. Recupera e configura le credenziali.
4. Installa l'operatore APIM.
5. Crea un'identità del workload.
6. Crea un ambiente Apigee.
7. Verifica la configurazione di GKE Gateway.

Imposta le variabili di ambiente

Nel progetto Google Cloud che contiene l'istanza Apigee, utilizza il seguente comando per impostare le variabili di ambiente:

export PROJECT_ID=PROJECT_ID
export CLUSTER_NAME=CLUSTER_NAME
export REGION=REGION
export APIGEE_ORG=APIGEE_ORG

Dove:

• PROJECT_ID è l'ID del progetto con la tua istanza Apigee.
• CLUSTER_NAME è il nome del tuo cluster GKE.
• REGION è la regione del cluster GKE.
• APIGEE_ORG è impostato sullo stesso valore di PROJECT_ID.

Per verificare che le variabili di ambiente siano impostate correttamente, esegui questo comando:

echo $PROJECT_ID $CLUSTER_NAME $REGION $APIGEE_ORG

Abilita le API richieste

L'operatore APIM richiede l'accesso alle seguenti API:

Nome	Titolo
apigee.googleapis.com	API Apigee
compute.googleapis.com	API Compute Engine
networkservices.googleapis.com	API Network Services
container.googleapis.com	API Google Kubernetes Engine

Utilizza il seguente comando per verificare che le API richieste siano abilitate:

gcloud services list --project=$PROJECT_ID

Se non vedi le API richieste elencate nell'output del comando, attivale:

gcloud services enable apigee.googleapis.com --project=$PROJECT_ID
gcloud services enable compute.googleapis.com --project=$PROJECT_ID
gcloud services enable networkservices.googleapis.com --project=$PROJECT_ID
gcloud services enable container.googleapis.com --project=$PROJECT_ID

Recuperare e configurare le credenziali

Recupera le credenziali del cluster e crea un account di servizio per connetterti ai servizi Google Cloud :

1. Recupera le credenziali del cluster utilizzando il seguente comando:

   gcloud container clusters get-credentials $CLUSTER_NAME --location=$REGION --project=$PROJECT_ID

   Queste credenziali vengono utilizzate per comunicare con il cluster GKE creato nei passaggi dei prerequisiti.

2. Configura le credenziali del service account per connetterti ai servizi Google Cloud :

   gcloud iam service-accounts create apigee-apim-gsa

3. Concedi i ruoli e le autorizzazioni richiesti al account di servizio che hai creato utilizzando i seguenti comandi:
   • Ruolo Amministratore Apigee: necessario per creare e gestire le risorse Apigee.

     gcloud projects add-iam-policy-binding $PROJECT_ID \
         --member "serviceAccount:apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com" \
         --role "roles/apigee.admin"

   • Ruolo di amministratore delle estensioni di servizio: necessario per creare e gestire le estensioni di servizio.

     gcloud projects add-iam-policy-binding $PROJECT_ID \
         --member "serviceAccount:apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com" \
         --role "roles/networkservices.serviceExtensionsAdmin"

   • Ruolo di amministratore di rete: necessario per gestire l'accesso ad Apigee utilizzando le estensioni di servizio.

     gcloud projects add-iam-policy-binding $PROJECT_ID \
         --member "serviceAccount:apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com" \
         --role "roles/compute.networkAdmin"

   • Ruolo Amministratore bilanciatore del carico: necessario per gestire l'accesso tra i gruppi di endpoint di rete (NEG) e i servizi di backend.

     gcloud projects add-iam-policy-binding $PROJECT_ID \
         --member "serviceAccount:apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com" \
         --role "roles/compute.loadBalancerAdmin"

     gcloud projects add-iam-policy-binding $PROJECT_ID \
         --member "serviceAccount:apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com" \
         --role "roles/iam.workloadIdentityUser"

Crea un'identità del workload

L'installazione di helm dell'operatore APIM nel passaggio successivo crea un account di servizio Kubernetes (KSA) obbligatorio denominato apim-ksa nello spazio dei nomi apim. Una volta creato, il KSA contiene l'annotazione richiesta per l'associazione a un'identità del workload utilizzata dall'operatore APIM per accedere alle risorse Apigee e Service Networking richieste.

Per creare l'identità del workload, utilizza il seguente comando:

gcloud iam service-accounts add-iam-policy-binding apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com --role roles/iam.workloadIdentityUser --member "serviceAccount:$PROJECT_ID.svc.id.goog[apim/apim-ksa]"

Questo comando associa il KSA al service account che hai creato in Recupera e configura le credenziali e assegna il ruolo workloadIdentityUser. Google

Potrebbero essere necessari alcuni minuti, potenzialmente 7 o più, prima che le modifiche all'identità del workload vengano propagate nel sistema.

Per verificare che l'identità del workload sia stata creata, utilizza i seguenti comandi:

gcloud config set project $PROJECT_ID

kubectl run --rm -it --image google/cloud-sdk:slim \
  --namespace apim workload-identity-test \
  --overrides='{ "spec": { "serviceAccountName": "apim-ksa" } }'  \
  -- gcloud auth list

L'output dovrebbe essere simile al seguente:

Credentialed Accounts
  ACTIVE  ACCOUNT
  *       GSA@$PROJECT_ID.iam.gserviceaccount.com

Installa le definizioni di risorse personalizzate (CRD) e l'operatore APIM

Installa le definizioni di risorse personalizzate (CRD) di Kubernetes e l'operatore APIM:

1. Crea uno spazio dei nomi per l'operatore APIM:

   kubectl create ns apim

2. Installa le definizioni di risorse personalizzate (CRD) dell'operatore APIM:

   helm install apigee-apim-crds -n apim \
     oci://us-docker.pkg.dev/apigee-release/apigee-k8s-tooling-helm-charts/apigee-apim-operator-crds \
     --version 1.0.0 \
     --atomic

3. Installa l'operatore APIM:

   helm install apigee-apim-operator -n apim \
     oci://us-docker.pkg.dev/apigee-release/apigee-k8s-tooling-helm-charts/apigee-apim-operator-helm \
     --version 1.0.0 \
     --set projectId=$PROJECT_ID \
     --set serviceAccount=apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com \
     --set apigeeOrg=$PROJECT_ID \
     --set generateEnv=TRUE \
     --atomic

4. Verifica che l'installazione sia stata completata correttamente:

   helm list -n apim

   L'output dovrebbe essere simile al seguente:

   NAME                	NAMESPACE	REVISION	UPDATED                                	STATUS  	CHART                          	APP VERSION
   apigee-apim-crds    	apim     	1       	2025-02-01 00:17:03.399810627 +0000 UTC	deployed	apigee-apim-operator-crds-1.0.0	1.0.0
   apigee-apim-operator	apim     	1       	2025-02-01 00:15:00.362829981 +0000 UTC	deployed	apigee-apim-operator-helm-1.0.0	1.0.0   

5. Verifica che la KSA sia stata creata con l'annotazione richiesta:

   kubectl describe serviceaccounts apim-ksa -n apim

   L'output dovrebbe essere simile al seguente:

   Name:                apim-ksa
   Namespace:           apim
   ...
   Annotations:         iam.gke.io/gcp-service-account: [e-mail]

6. Verifica che l'operatore APIM sia in esecuzione nei pod del cluster:

   kubectl get pods -n apim

   L'output dovrebbe essere simile al seguente:

   NAME                                    READY   STATUS    RESTARTS     AGE
   apigee-apim-operator-8559d4994b-h55fl   1/1     Running   0            8m34s
   

   Se STATUS non è Running o READY non mostra 1/1, consulta Risolvere i problemi relativi all'operatore APIM per risolvere i problemi di installazione.

Crea un ambiente Apigee

Se hai installato l'operatore APIM utilizzando generateEnv=TRUE nel passaggio precedente, l'operatore crea un nuovo ambiente Apigee quando viene creata e applicata la policy di estensione APIM. Il nome del nuovo ambiente avrà il prefisso: apim-enabled-dep-env.

Se hai installato l'operatore APIM con generateEnv=FALSE, devi creare un nuovo ambiente Apigee:

1. Imposta TOKEN richiesto per il comando curl:

   export TOKEN=$(gcloud auth print-access-token)

2. Crea l'ambiente utilizzando uno dei seguenti comandi:
   • Per le organizzazioni con abbonamento 2021:

     curl -X POST "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/environments" -H \
       "Authorization: Bearer $TOKEN" -H "content-type:application/json" \
         -d '{
           "name": "ENV_NAME",
           "displayName": "ENV_NAME",
           "state": "ACTIVE",
           "deploymentType": "PROXY",
           "apiProxyType": "PROGRAMMABLE",
           "properties": {
             "property": [
               {
                 "name": "apigee-service-extension-enabled",
                 "value": "true"
               }
             ]
           }
       }'

     Dove ENV_NAME è il nome dell'ambiente da creare.

   • Per le organizzazioni con abbonamento 2024 e pagamento a consumo:

     curl -i -X POST -H "Authorization: Bearer $TOKEN"  "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/environments" -H "Content-Type:application/json" -d '{
       "name": "ENV_NAME",
       "displayName": "ENV_NAME",
       "state": "ACTIVE",
       "deploymentType": "PROXY",
       "apiProxyType": "PROGRAMMABLE",
       "type" : "COMPREHENSIVE",
       "properties": {
         "property": [
           {
             "name": "apigee-service-extension-enabled",
             "value": "true"
           }
         ]
       }
     }'

     Dove:

     • ENV_NAME è il nome dell'ambiente da creare.
     • ENV_TYPE è il tipo di ambiente da creare. Ad esempio, INTERMEDIATE o COMPREHENSIVE.
     Nota: l'ambiente creato in questo passaggio o dall'operatore APIM è un ambiente intermedio o completo, per supportare l'utilizzo di proxy estensibili. Questa funzionalità non può essere utilizzata con gli ambienti di base.

   Per verificare che l'ambiente sia stato creato correttamente:

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

3. Collega l'ambiente all'istanza Apigee:

   curl -i -X POST -H "Authorization: Bearer $TOKEN" \
     "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/instances/INSTANCE_NAME/attachments" \
     -H "Content-Type:application/json" -d '{"environment": "ENV_NAME"}'

   Dove:

   • INSTANCE_NAME è il nome della tua istanza Apigee.
   • ENV_NAME è il nome dell'ambiente che hai creato nel passaggio precedente.

   Per controllare lo stato dell'operazione di collegamento dell'ambiente:

   curl -X GET -H "Authorization: Bearer $TOKEN" \
     "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/operations/OPERATION_ID"

   Dove OPERATION_ID è l'ID dell'operazione di allegato dell'ambiente.

Risoluzione dei problemi

Se riscontri problemi durante l'installazione dell'operatore APIM, consulta la sezione Risoluzione dei problemi dell'operatore APIM per trovare soluzioni agli errori comuni.

Passaggi successivi

• Utilizza le norme Apigee con l'operatore APIM.
• Aggiungi criteri Apigee al gateway GKE.