Questa pagina è stata tradotta dall'API Cloud Translation.

Installa l'operatore Apigee per Kubernetes per Apigee hybrid

Questa pagina si applica ad Apigee e Apigee hybrid.

Visualizza la documentazione di Apigee Edge.

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

Se non utilizzi Apigee hybrid, consulta Installare l'operatore Apigee per Kubernetes per installare l'operatore Apigee per Kubernetes per Apigee.

Prima di iniziare

Prima di iniziare, assicurati di disporre di quanto segue:

Ruoli obbligatori

Per le autorizzazioni necessarie per configurare le risorse richieste per installare e utilizzare l'operatore Apigee per Kubernetes, chiedi all'amministratore di concederti i seguenti ruoli IAM nell'organizzazione:

Crea e gestisci service account: amministratore service account (roles/iam.serviceAccountAdmin)
Crea e gestisci risorse Apigee: Apigee Admin (roles/apigee.admin)

Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

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

Attività di configurazione richieste

Prima di installare l'operatore Apigee per Kubernetes, assicurati di completare le seguenti attività per configurare le risorse necessarie per utilizzare la funzionalità:

Installa Apigee hybrid utilizzando la versione 1.15.0 o successive. Per istruzioni su come installare Apigee hybrid, consulta Il quadro generale.
Crea un cluster Kubernetes in un provider cloud che supporti Istio Gateway, ad esempio Google Cloud, Azure o Amazon.
Nota: le istruzioni di queste procedure sono pensate per funzionare con le installazioni su qualsiasi provider che supporti Istio Gateway. I passaggi che utilizzano gcloud riguardano la comunicazione con il progetto Google Cloud che contiene l'istanza Apigee hybrid.

Installa Istio Gateway nel tuo cluster K8s:

Per i cluster su GKE:

kubectl apply -f https://github.com/kubernetes-sigs/gateway-api/releases/download/v1.1.0/standard-install.yaml
curl -L https://istio.io/downloadIstio | sh -
cd 1.6.11-asm.1
export PATH=$PWD/bin:$PATH
istioctl install --set profile=minimal --set values.global.platform=gke -y

Per i cluster su altri fornitori:

kubectl apply -f https://github.com/kubernetes-sigs/gateway-api/releases/download/v1.1.0/standard-install.yaml
curl -L https://istio.io/downloadIstio | sh -
cd 1.6.11-asm.1
export PATH=$PWD/bin:$PATH
istioctl install --set profile=minimal -y

Esegui il deployment di Istio Gateway nel cluster Kubernetes.
1. Crea un file denominato gateway.yaml con i seguenti contenuti per eseguire il deployment di Istio Gateway con i seguenti contenuti:
```
#gateway.yaml
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: istio-gateway
  namespace: default
  annotations:
    service.beta.kubernetes.io/port_80_health-probe_protocol: tcp
spec:
  gatewayClassName: istio
  listeners:
  - name: default
    hostname: "*.httpbin.com"
    port: 80
    protocol: HTTP
    allowedRoutes:
      namespaces:
        from: All
```
  Nota:l'annotazione nei metadati è necessaria solo per i cluster su AKS a causa del problema aperto di Istio 46769. Puoi omettere i metadati per gli altri cluster Kubernetes.
2. Applica il file al cluster con il seguente comando:
```
kubectl apply -f gateway.yaml
```

Verifica la configurazione di Istio Gateway (facoltativo)

Ai fini di questa guida, ti consigliamo di eseguire il deployment di un'applicazione httpbin di esempio nello spazio dei nomi predefinito per testare il gateway di cui hai eseguito il deployment.

Esegui il deployment di un'applicazione di backend nel cluster Kubernetes per testare il gateway.
1. Crea un nuovo file denominato target.yaml con i seguenti contenuti:
```
kubectl apply -f - <<EOF
apiVersion: v1
kind: ServiceAccount
metadata:
  name: httpbin
---
apiVersion: v1
kind: Service
metadata:
  name: httpbin
  labels:
    app: httpbin
    service: httpbin
spec:
  ports:
  - name: http
    port: 8000
    targetPort: 8080
  selector:
    app: httpbin
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: httpbin
spec:
  replicas: 1
  selector:
    matchLabels:
      app: httpbin
      version: v1
  template:
    metadata:
      labels:
        app: httpbin
        version: v1
    spec:
      serviceAccountName: httpbin
      containers:
      - image: docker.io/mccutchen/go-httpbin:v2.15.0
        imagePullPolicy: IfNotPresent
        name: httpbin
        ports:
        - containerPort: 8080
EOF
```
  Suggerimento: puoi anche salvare le righe tra i tag <<EOF e EOF come file denominato target.yaml. Quindi, applica la configurazione al tuo cluster con il seguente comando:
```
kubectl apply -f target.yaml
```
2. Esegui il deployment della risorsa HTTPRoute nel cluster per mappare il traffico dal gateway al servizio di backend.
  Ai fini di questa guida, ti consigliamo di eseguire il deployment di un gateway e di un HTTPRoute esterni seguendo i passaggi descritti in Creare un HTTPRoute.
  
  Per ulteriori informazioni sulla risorsa HTTPRoute, consulta Deploy the HTTPRoute (per i gateway interni) o Create an HTTPRoute (per i gateway esterni).
  1. Crea un HTTPRoute seguendo le istruzioni riportate in Crea HTTPRoute utilizzando la seguente configurazione YAML:
```
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: http-bin-route
  namespace: default
spec:
  parentRefs:
  - name: istio-gateway
    namespace: default
  hostnames: ["example.httpbin.com"]
  rules:
  - matches:
    - path:
        type: PathPrefix
        value: /get
    backendRefs:
    - name: httpbin
      port: 8000
```
  2. Applica il file al cluster:
```
kubectl apply -f httproute.yaml
```
3. Verifica la configurazione di GKE Gateway per confermare che funzioni come previsto.
  Nota:la propagazione delle modifiche applicate può richiedere fino a cinque minuti. Se non vedi l'output previsto per i passaggi di questa sezione, attendi qualche minuto e riprova.
  1. Recupera i dettagli del gateway utilizzando il seguente comando
```
kubectl get gateway global-ext-lb1
```
    L'output dovrebbe essere simile al seguente:
```
NAME            CLASS   ADDRESS        PROGRAMMED   AGE
istio-gateway   istio   34.54.193.72   True         11d
```
    Verifica che al gateway sia assegnato un indirizzo IP e che il valore di PROGRAMMED sia True.
  2. Descrivi il gateway per confermare che l'itinerario sia allegato:
```
kubectl describe gateway istio-gateway
```
    L'output dovrebbe essere simile al seguente:
```
...
  Listeners:
    Attached Routes: 1
    Conditions:
      Last Transition Time:  2024-10-03T03:10:17Z
...
```
    Verifica che il valore di Attached Routes (Percorsi collegati) sia 1, a indicare che il percorso è collegato.
  3. Inviare una richiesta al gateway
```
curl http://GATEWAY_IP_ADDRESS/get \
  -H "Host: example.httpbin.com"
```
    Dove: GATEWAY_IP_ADDRESS è l'indirizzo IP del gateway. Puoi recuperare l'indirizzo IP del gateway utilizzando il seguente comando, dove GATEWAY_NAME è il nome del gateway:
```
kubectl get gateways.gateway.networking.k8s.io GATEWAY_NAME -o=jsonpath="{.status.addresses.value}"
```
    Ad esempio:
```
curl http://34.54.193.72/get -H "Host: example.httpbin.com"
```
    La risposta dovrebbe essere simile alla seguente:
```
{
    "args": {},
    "headers": {
      "Accept": "*/*",
      "Host": "http://example.httpbin.com",
      "User-Agent": "curl/8.7.1",
      "X-Cloud-Trace-Context": "2bb8a80e29e80662ff9cb89971c447d9/13083106619927322701"
    },
    "origin": "67.164.1.10,34.54.193.72",
    "url": "http://example.httpbin.com/get"
}
```
Installa l'operatore Apigee per Kubernetes

Questa procedura descrive i passaggi necessari per installare e configurare l'operatore Apigee per Kubernetes.
Installa e configura l'operatore Apigee per Kubernetes

Le sezioni seguenti descrivono i passaggi necessari per installare e configurare l'operatore Apigee per Kubernetes:
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 APIGEE_ORG=APIGEE_ORG
```
Dove:
- PROJECT_ID è l'ID del progetto con l'istanza Apigee Hybrid.
- APIGEE_ORG è il nome dell'organizzazione della tua istanza Apigee Hybrid.
Verifica che le variabili di ambiente siano impostate correttamente con il comando seguente:
```
echo $PROJECT_ID $APIGEE_ORG
```
Crea e configura il account di servizio APIM

Crea un account di servizio per connetterti al piano di configurazione di Apigee Hybrid.
1. Crea il account di servizio apigee-apim-gsa per connetterti ai servizi Google Cloud
2. Concedi il ruolo Apigee Admin al account di servizio che hai creato utilizzando il seguente comando. Questo ruolo è 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"
```
3. Scarica il file della chiave JSON corrispondente per il account di servizio.
  1. Crea e scarica il file della chiave $PROJECT_ID-apigee-apim-gsa.json con il seguente comando:
```
gcloud iam service-accounts keys create $PROJECT_ID-apigee-apim-gsa.json \
  --iam-account=apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com
  --project=$PROJECT_ID
        
```
  2. Verifica che il file sia stato scaricato correttamente:
```
ls $PROJECT_ID-apigee-apim-gsa.json
        
```
Installa 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 namespace apim
```
2. Installa le definizioni di risorse personalizzate (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 serviceAccount=apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com \
  --set apigeeOrg=$APIGEE_ORG \
  --set apigeeEnv=ENV_NAME \
  --set-file serviceAccountKeyFileContent=$PROJECT_ID-apigee-apim-gsa-key.json \
  --atomic
```
  dove ENV_NAME è il nome dell'ambiente Apigee Hybrid in cui vuoi installare l'operatore Apigee per Kubernetes.
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-09-01 00:17:03.399810627 +0000 UTC  deployed  apigee-apim-operator-crds-1.1.0  1.1.0
apigee-apim-operator  apim  1  2025-09-01 00:15:00.362829981 +0000 UTC  deployed  apigee-apim-operator-helm-1.1.0  1.1.0
```
5. Verifica che il account di servizio Kubernetes (KSA) sia stato creato 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: apigee-apim-gsa@my-project-id.iam.gserviceaccount.com
```
6. Verifica che l'operatore Apigee per Kubernetes 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 Apigee per Kubernetes per risolvere i problemi di installazione.
Creare un ambiente Apigee hybrid

Per utilizzare l'operatore Apigee per Kubernetes in Apigee Hybrid, devi creare un ambiente con un flag speciale per l'estensione del servizio.
1. Ottieni un token per l'autenticazione nell'API Apigee.
  Nella riga di comando, recupera le credenziali di autenticazione gcloud, come mostrato nell'esempio seguente:
```
TOKEN=$(gcloud auth print-access-token)
```
  Per verificare che il token sia stato compilato, utilizza echo, come mostrato nell'esempio seguente:
```
echo $TOKEN
```
  Dovrebbe essere visualizzato il token come stringa codificata.
  
  Per saperne di più, consulta la panoramica dello strumento a riga di comando gcloud.
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_DISPLAY_NAME",
      "state": "ACTIVE",
      "deploymentType": "PROXY",
      "apiProxyType": "PROGRAMMABLE",
      "properties": {
        "property": [
          {
            "name": "apigee-service-extension-enabled",
            "value": "true"
          }
        ]
      }
    }'
```
    Dove ENV_NAME è il nome dell'ambiente che vuoi 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" : "ENV_TYPE",
  "properties": {
    "property": [
      {
        "name": "apigee-service-extension-enabled",
        "value": "true"
      }
    ]
  }
}'
```
    Dove:
    - ENV_NAME è il nome dell'ambiente che vuoi creare.
    - ENV_TYPE è il tipo di ambiente che vuoi creare. Ad esempio, INTERMEDIATE o COMPREHENSIVE.
  Verifica che l'ambiente sia stato creato correttamente:
```
curl -i -H "Authorization: Bearer $TOKEN" \
  "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/environments"
```
  Per ulteriori informazioni, consulta Creare un ambiente nelle istruzioni di installazione di Apigee hybrid.
3. Crea un gruppo di ambienti con il seguente comando:
```
curl -i -X POST -H "Authorization: Bearer $TOKEN"  "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/envgroups" -H "Content-Type:application/json" -d '{
     "name": "'"$ENV_GROUP"'",
     "hostnames":["'"$DOMAIN"'"]
   }'
```
  Dove:
  - ENV_GROUP (obbligatorio) Il nome dell'ambiente può contenere lettere minuscole, trattini e numeri e deve iniziare con una lettera minuscola. Questo nome verrà utilizzato come identificatore e non potrà essere modificato dopo la creazione.
  - DOMAIN (obbligatorio). Questo è il nome host che tutti i proxy di cui è stato eseguito il deployment negli ambienti all'interno di questo gruppo utilizzeranno. Deve essere un dominio che gestisci. L'indirizzo può essere il dominio stesso, ad esempio example.com, oppure può includere un sottodominio come my-proxies.example.com. Se non hai un dominio gestito, per il momento puoi inserire un segnaposto. Puoi modificare l'indirizzo del dominio in un secondo momento.
  Per saperne di più, consulta Crea un gruppo di ambienti nelle istruzioni di installazione di Apigee hybrid.
4. Collega l'ambiente al gruppo di ambienti appena creato con il seguente comando:
```
curl -i -X POST -H "Authorization: Bearer $TOKEN"  "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/envgroups/$ENV_GROUP/attachments" -H "Content-Type:application/json" -d '{
     "environment": "'"$ENV_NAME"'",
   }'
```
Installa l'ambiente Apigee Hybrid utilizzando Helm

La procedura per installare il nuovo ambiente nel cluster Apigee Hybrid è simile a quella per installare altri ambienti nel cluster. Queste informazioni sono necessarie per aggiungere nuovi dettagli sull'ambiente e sul gruppo di ambienti al nostro cluster Kubernetes in cui è stato installato Apigee Hybrid.
1. Genera il certificato TLS per il dominio del gruppo di ambienti con il seguente comando:
```
openssl req -nodes -new -x509 -keyout $APIGEE_HELM_CHARTS_HOME/apigee-virtualhost/certs/keystore_$ENV_GROUP.key -out $APIGEE_HELM_CHARTS_HOME/apigee-virtualhost/certs/keystore_$ENV_GROUP.pem -subj "/CN=$DOMAIN" -addext "subjectAltName = DNS:$DOMAIN" -days 3650
```
  Dove:
  - APIGEE_HELM_CHARTS_HOME (Obbligatorio) Directory in cui hai scaricato i grafici Helm di Apigee durante l'installazione di Apigee Hybrid.
2. Codifica in base64 il certificato pubblico TLS con il seguente comando:
```
cat $APIGEE_HELM_CHARTS_HOME/apigee-virtualhost/certs/keystore_$ENV_GROUP.pem | base64 -w0 > $APIGEE_HELM_CHARTS_HOME/apigee-virtualhost/certs/keystore_$ENV_GROUP.pem.base64
```
3. Aggiorna il file overrides.yaml con la seguente voce in envs
```
- name: ENV_NAME
  serviceAccountPaths:
    # Provide the path relative to the apigee-env chart directory.
    synchronizer: SYNCHRONIZER_SERVICE_ACCOUNT_FILEPATH
    # For example: "PROJECT_ID-apigee-synchronizer.json"
    runtime: RUNTIME_SERVICE_ACCOUNT_FILEPATH
    # For example: "PROJECT_ID-apigee-runtime.json"
    udca: UDCA_SERVICE_ACCOUNT_FILEPATH
    # For example: "PROJECT_ID-apigee-udca.json"
```
  Dove *_SERVICE_ACCOUNT_FILEPATH (obbligatorio) è il file della chiave JSON dell'account di servizio che hai utilizzato durante l'installazione di Apigee Hybrid. Per saperne di più, consulta Crea gli override nelle istruzioni di installazione di Apigee Hybrid.
4. Aggiungi la seguente voce nel file overrides.yaml in virtualhosts
```
- name: 
  selector:
    app: apigee-ingressgateway
    ingress_name: INGRESS_NAME
  sslCertPath: certs/keystore_$ENV_GROUP.pem
  sslKeyPath: certs/keystore_$ENV_GROUP.key
```
  Dove INGRESS_NAME (obbligatorio) è il nome del gateway in entrata Apigee per la tua implementazione. Per ulteriori informazioni, consulta questa pagina.
5. Installa l'ambiente e il gruppo di ambienti
  1. Installa l'ambiente.
    
    Devi installare un ambiente alla volta. Specifica l'ambiente con --set env=ENV_NAME. Se hai impostato la variabile di ambiente $ENV_NAME nella shell, puoi utilizzarla nei comandi seguenti:
    
    Prova:
```
helm upgrade ENV_RELEASE_NAME apigee-env/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  --set env=$ENV_NAME \
  -f overrides.yaml \
  --dry-run=server
```
    Installa il grafico:
```
helm upgrade ENV_RELEASE_NAME apigee-env/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  --set env=$ENV_NAME \
  -f overrides.yaml
```
    Verifica che sia attivo e funzionante controllando lo stato dell'ambiente corrispondente:
```
kubectl -n APIGEE_NAMESPACE get apigeeenv
```
```
NAME                    STATE       AGE   GATEWAYTYPE
apigee-org1-dev-1       running     2d
```
  2. Installa i gruppi di ambienti (virtualhosts).
    1. Devi installare un gruppo di ambienti (virtualhost) alla volta. Specifica il gruppo di ambienti con --set envgroup=ENV_GROUP. Se hai impostato la variabile di ambiente $ENV_GROUP nella shell, puoi utilizzarla nei comandi seguenti. Ripeti i seguenti comandi per ogni gruppo di ambienti menzionato nel file overrides.yaml:
      Prova:
      helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \ --install \ --namespace APIGEE_NAMESPACE \ --atomic \ --set envgroup=$ENV_GROUP \ -f overrides.yaml \ --dry-run=server
      Installa il grafico:
      helm upgrade $ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \ --install \ --namespace APIGEE_NAMESPACE \ --atomic \ --set envgroup=$ENV_GROUP \ -f overrides.yaml
      Nota: ENV_GROUP deve essere univoco all'interno dello spazio dei nomi apigee. Ad esempio, se hai un ambiente prod e un gruppo di ambienti, devi impostare questo nome su prod-envgroup. Il nome del gruppo di ambienti successivo deve comunque essere prod.
  La tua organizzazione Apigee Hybrid è ora pronta con il nuovo ambiente per testare l'estensione del servizio.
  
  Continua con le procedure descritte in Creare una policy di estensione APIMExtensionPolicy per creare una policy di estensione.

Installa l'operatore Apigee per Kubernetes per Apigee hybrid Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Prima di iniziare

Ruoli obbligatori

Attività di configurazione richieste

Verifica la configurazione di Istio Gateway (facoltativo)

Installa l'operatore Apigee per Kubernetes

Installa e configura l'operatore Apigee per Kubernetes

Imposta le variabili di ambiente

Crea e configura il account di servizio APIM

Installa l'operatore Apigee per Kubernetes

Creare un ambiente Apigee hybrid

Installa l'ambiente Apigee Hybrid utilizzando Helm

Installa l'operatore Apigee per Kubernetes per Apigee hybrid