Installa l'operatore 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 per installare e configurare l'operatore Apigee per Kubernetes. Per saperne di più sui vantaggi dell'utilizzo di Apigee Operator per Kubernetes, consulta la panoramica di Apigee Operator per Kubernetes.

Prima di iniziare

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

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per installare l'operatore Apigee per Kubernetes, 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 Apigee per Kubernetes

Le sezioni seguenti descrivono i passaggi per installare e configurare l'operatore Apigee per Kubernetes:

1. Imposta le variabili di ambiente.
2. Abilita le API richieste.
3. Recupera e configura le credenziali.
4. Installa l'operatore Apigee per Kubernetes.
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

Apigee Operator per Kubernetes 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 comunicano 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 di Apigee Operator per Kubernetes 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 necessaria per l'associazione a un'identità del carico di lavoro utilizzata dall'operatore Apigee per Kubernetes 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 Apigee per Kubernetes

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

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

   kubectl create ns apim

2. Installa le CRD dell'operatore Apigee per Kubernetes:

   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.1.0 \
     --atomic

3. Installa l'operatore Apigee per Kubernetes:

   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.1.0 \
     --set projectId=$PROJECT_ID \
     --set serviceAccount=apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com \
     --set apigeeOrg=$PROJECT_ID \
     --set generateEnv=ENV_GENERATION_MODE \
     --atomic

Sostituisci ENV_GENERATION_MODE con TRUE se vuoi che l'operatore crei un nuovo ambiente Apigee quando viene installato l'operatore Apigee per Kubernetes. Imposta ENV_GENERATION_MODE su FALSE se vuoi creare l'ambiente manualmente dopo l'installazione dell'operatore. Per saperne di più, vedi Creare un ambiente Apigee.

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.1.0	1.1.0
   apigee-apim-operator	apim     	1       	2025-02-01 00:15:00.362829981 +0000 UTC	deployed	apigee-apim-operator-helm-1.1.0	1.1.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 se READY non mostra 1/1, consulta Risoluzione dei problemi relativi all'operatore Apigee per Kubernetes per risolvere i problemi relativi all'installazione.

Crea un ambiente Apigee

Se hai installato l'operatore Apigee per Kubernetes 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 ha il prefisso: apim-enabled-dep-env.

Se hai installato l'operatore Apigee per Kubernetes 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 Apigee per Kubernetes è 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 di Apigee Operator per Kubernetes, consulta la sezione Risolvere i problemi di Apigee Operator per Kubernetes per trovare soluzioni agli errori comuni.

Passaggi successivi

Crea un'estensione di servizio del traffico utilizzando APIMExtensionPolicy o ApigeeBackendService:

• Creare un APIMExtensionPolicy
• Creare un ApigeeBackendService