Questa pagina è stata tradotta dall'API Cloud Translation.

Aggiorna le norme di gestione delle API con l'operatore APIM di Apigee per Kubernetes

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

Visualizza la documentazione di Apigee Edge.

Man mano che le tue esigenze di gestione delle API crescono e cambiano, potresti dover aggiungere nuovi servizi al cluster o aggiornare le opzioni di ingressi e route esistenti. Questa pagina descrive come aggiornare il cluster per completare le seguenti attività:

Aggiungi un nuovo gateway e un nuovo HTTPRoute.
Aggiorna un prodotto API.
Crea un nuovo prodotto API.
Crea un nuovo insieme di operazioni API.
Testa la nuova configurazione del gateway.

Prima di iniziare

Prima di iniziare questa attività, assicurati di completare i passaggi descritti in Applicare un criterio con l'operatore APIM di Apigee per Kubernetes. Questa pagina presuppone che tu abbia configurato un cluster Google Kubernetes Engine (GKE), installato l'operatore APIM di Apigee per Kubernetes, creato un gateway Google Kubernetes Engine (GKE) e applicato almeno un criterio di gestione delle API al gateway.

Ruoli obbligatori

Se hai assegnato i ruoli richiesti al tuo account di servizio come descritto in Installa l'operatore APIM di Apigee per Kubernetes, non sono richieste autorizzazioni o ruoli IAM aggiuntivi per completare queste attività.

Puoi scegliere di autorizzare le azioni sulle risorse nel cluster Google Kubernetes Engine utilizzando il meccanismo di controllo dell'accesso basato sui ruoli (RBAC) integrato in Kubernetes. Per ulteriori informazioni, consulta Autorizzare le azioni nei cluster utilizzando il controllo degli accessi basato sui ruoli.

Aggiungi un nuovo gateway e HTTPRoute

In questa sezione aggiungerai un nuovo gateway e un nuovo percorso HTTP al tuo cluster. Nelle guide alle attività precedenti, le configurazioni di esempio utilizzavano un gateway GKE esterno. Se vengono dimessi più gateway nella stessa regione, devono essere dello stesso tipo (entrambi esterni o entrambi interni). Per questo motivo, la configurazione di esempio in questa guida utilizzerà anche un gateway esterno.

L'operatore APIM può essere utilizzato con gateway GKE interni o esterni, ma non puoi implementare entrambi i tipi di gateway nella stessa regione.

Per aggiungere un nuovo gateway e un nuovo percorso HTTP al cluster:

Configura un nuovo gateway GKE esterno. Per ulteriori informazioni e passaggi, consulta Eseguire il deployment di un gateway esterno.
Crea un nuovo file denominato gateway2.yaml nello spazio dei nomi apim.

Copia i seguenti contenuti nel nuovo file:

# gateway2.yaml
apiVersion: gateway.networking.k8s.io/v1beta1
kind: Gateway
metadata:
  name: global-ext-lb2
  spec: 
  gatewayClassName: gke-l7-global-external-managed
  listeners:
  - name: https
    protocol: HTTPS
    allowedRoutes:
      kinds:
      - kind: HTTPRoute
      namespaces:
        from: All
    port: 443
    tls:
      options:
        networking.gke.io/pre-shared-certs: apigee-lb-new-cert-sept

Aggiungi un nuovo percorso HTTP per /post allo stesso file, come evidenziato di seguito:

# http-route2.yaml
  apiVersion: gateway.networking.k8s.io/v1beta1
  kind: HTTPRoute
  metadata:
    name: http-bin-route-post
    namespace: http
  spec:
    parentRefs:
      - kind: Gateway
        name: global-ext-lb2
        namespace: default
    hostnames:
      - HOST_NAME_2
    rules:
    - matches:
      - path:
          type: PathPrefix
          value: "/post"
      backendRefs:
      - name: httpbin
        kind: Service
        port: 80
        namespace: http

Applica il nuovo gateway e HTTPRoute:
```
kubectl apply -f gateway2.yaml
```

Controlla lo stato di HTTPRoute utilizzando il seguente comando:

kubectl -n http get HttpRoute

L'output dovrebbe essere simile al seguente:

NAME             HOSTNAMES                                                  AGE
http-bin-route   ["my-hostname-2"]   12d

Controlla lo stato della porta di accesso utilizzando il seguente comando:
```
kubectl get gateway global-ext-lb2
```
L'output dovrebbe essere simile al seguente:
```
NAME             CLASS                            ADDRESS        PROGRAMMED   AGE
global-ext-lb2   gke-l7-global-external-managed   34.54.193.92   True         11d
```
Verifica che la colonna Address contenga un indirizzo IP valido e che lo stato di Programmed sia True.
Descrivi il gateway per assicurarti che il percorso sia collegato:
```
kubectl describe gateway global-ext-lb2
```

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 sia 1.

Invia una richiesta al gateway per verificare che il percorso funzioni:
```
curl -X POST http://GATEWAY_IP_ADDRESS/post -H "Host: HOST_NAME"
```
Dove:
- GATEWAY_IP_ADDRESS è l'indirizzo IP del gateway, come mostrato nella colonna Address della risposta restituita nel passaggio 7.
- HOST_NAME è il nome host definito in HTTPRoute del gateway.

L'output dovrebbe essere simile al seguente:

  {
    "args": {}, 
    "headers": {
      "Accept": "*/*", 
      "Host": "apigee-apim-operator-test.apigee.net", 
      "User-Agent": "curl/8.7.1", 
      "X-Cloud-Trace-Context": "2bb8a80e29e80662ff9cb89971c447d9/13083106619927322701"
    }, 
    "origin": "67.164.1.10,34.54.193.72", 
    "url": "https://apigee-apim-operator-test.apigee.net/post"
  }

Crea un nuovo criterio di estensione APIM che fa riferimento all'attributo HTTPRoute del nuovo gateway creato in un passaggio precedente:
1. Crea un nuovo file denominato apim-policy2.yaml nello spazio dei nomi apim.
2. Copia i seguenti contenuti nel nuovo file:
```
# apim-policy2.yaml
apiVersion: apim.googleapis.com/v1alpha1
kind: APIMExtensionPolicy
metadata:
  name: global-ext-lb2-apim-policy-2
  namespace: apim
spec:
  location: global
  failOpen: false
  timeout: 1000ms
  targetRef: # identifies the Gateway where the extension should be installed
    name: global-ext-lb2 
    kind: Gateway
    namespace: default
```
3. Applica il nuovo criterio di estensione APIM:
```
kubectl apply -f apim-policy2.yaml
```
  Una volta applicato il file, APIM Operator crea le risorse di networking in background.
4. Controlla lo stato delle norme relative alle estensioni APIM:
```
kubectl -n apim get APIMExtensionPolicy
```
  L'output dovrebbe essere simile al seguente:
```
NAME                           STATE        ERRORMESSAGE
global-ext-lb2-apim-policy-2   RUNNING  
```
  Verifica che il valore di STATE sia RUNNING.
5. Attendi cinque minuti per assicurarti che le modifiche vengano propagate a tutte le istanze del bilanciatore del carico, quindi utilizza il seguente comando per verificare che una richiesta al nuovo gateway non vada a buon fine:
```
curl -X POST http://GATEWAY_IP_ADDRESS/post -H "Host: HOSTNAME"
```
  Dove:
  - GATEWAY_IP_ADDRESS è l'indirizzo IP del gateway ottenuto in un passaggio precedente.
  - HOST_NAME è il nome host definito in HTTPRoute del gateway.
  La richiesta dovrebbe non riuscire con una risposta simile alla seguente:
```
{
  "fault": {
    "faultstring": "Raising fault. Fault name : RF-insufficient-request-raise-fault",
    "detail": {
      "errorcode": "steps.raisefault.RaiseFault"
    }
  }
}
```
  Ciò significa che l'estensione del servizio ad Apigee è attiva e la verifica della chiave API e del token di accesso è applicata. Per i passaggi necessari per creare un'app per sviluppatori, ottenere una chiave API e testare il nuovo gateway con la chiave, consulta Testare l'estensione di servizio Apigee.

Aggiornare un prodotto API

Modifica un prodotto API esistente in modo da fare riferimento al nuovo criterio di estensione APIM:

Crea un nuovo file denominato api-product-2.yaml nello spazio dei nomi apim.

Copia i seguenti contenuti nel nuovo file:

# api-product-2.yaml
apiVersion: apim.googleapis.com/v1alpha1
kind: APIProduct
metadata:
  name: api-product-2
  namespace: apim
spec:
  name: api-product-2
  approvalType: auto
  description: Http bin GET calls
  displayName: api-product-2
EnforcementRefs:
  - name: global-ext-lb1-apim-policy 
    kind: APIMExtensionPolicy
    group: apim.googleapis.com
    namespace: apim
  - name: global-ext-lb2-apim-policy 
    kind: APIMExtensionPolicy
    group: apim.googleapis.com
    namespace: apim
  attributes:
  - name: access
    value: private

Applica il nuovo file di prodotto dell'API:
```
kubectl apply -f api-product-2.yaml
```
L'applicazione delle modifiche all'intero cluster richiede circa tre minuti.

In questo esempio, la sezione EnforcementRefs del prodotto dell'API api-product-2 viene aggiornata per fare riferimento sia a global-ext-lb1-apim-policy che a global-ext-lb2-apim-policy, come mostrato nelle parti evidenziate di yaml.

Creare un nuovo prodotto API

Crea un nuovo prodotto API:

Crea un nuovo file denominato api-product-2.yaml nello spazio dei nomi apim.

Copia i seguenti contenuti nel nuovo file:

# api-product-2.yaml
apiVersion: apim.googleapis.com/v1alpha1
kind: APIProduct
metadata:
  name: api-product-2
  namespace: apim
spec:
  name: api-product-2
  approvalType: auto
  description: Http bin GET calls
  displayName: api-product-2
  enforcementRefs:
  - name: global-ext-lb2-apim-policy 
    kind: APIMExtensionPolicy
    group: apim.googleapis.com
    namespace: apim
  attributes:
  - name: access
    value: private

Applica il nuovo file di prodotto dell'API:
```
kubectl apply -f api-product-2.yaml
```
L'applicazione delle modifiche all'intero cluster richiede circa tre minuti.

In questo esempio, la sezione EnforcementRefs del nuovo prodotto API api-product-2 viene creata per fare riferimento a global-ext-lb2-apim-policy, come mostrato nelle parti evidenziate di yaml.

Crea un nuovo insieme di operazioni API

Crea un nuovo insieme di operazioni API:

Crea un nuovo file denominato item-set-post.yaml nello spazio dei nomi apim.

Copia i seguenti contenuti nel nuovo file:

# item-set-post.yaml
apiVersion: apim.googleapis.com/v1alpha1
kind: APIOperationSet
metadata:
  name: item-set-post
  namespace: apim
spec:
  apiProductRefs:
    - name: api-product-1
      kind: APIProduct
      group: apim.googleapis.com
      namespace: apim
  quota:
    limit: 1
    interval: 1
    timeUnit: minute
  restOperations:
    - name: PostItems
      path: "/post"
      methods:
      - POST

Applica il nuovo file del set di operazioni dell'API:
```
kubectl apply -f item-set-post.yaml
```
L'applicazione delle modifiche all'intero cluster richiede circa tre minuti.

In questo esempio, viene creato il valore restOperations del nuovo insieme di operazioni dell'API item-set-post per fare riferimento al percorso /post, come mostrato nelle parti evidenziate del file.

Testa la nuova configurazione del gateway

Per testare la nuova configurazione del gateway, invia la seguente richiesta al nuovo percorso /post:

curl -X POST http://GATEWAY_IP_ADDRESS/post -H "Host: HOST_NAME"

Dove:

GATEWAY_IP_ADDRESS è l'indirizzo IP del gateway ottenuto in un passaggio precedente.
HOST_NAME è il nome host definito in HTTPRoute del gateway.

La richiesta dovrebbe riuscire e restituire una risposta simile alla seguente:

{
  "args": {},
  "headers": {
    "Accept": "*/*",
    "Host": "apigee-apim-operator-test.apigee.net",
    "User-Agent": "curl/8.7.1",
    "X-Api-Key": "f0N6sXXXclGXXXe0oP5XXXdA20PjgrP2x8xXXh7z4XXXKiYt",
    "X-Cloud-Trace-Context": "bb3a768787099bda628781188bfb318b/15554891713516675739"
  },
  "origin": "34.54.193.72",
  "url": "https://34.54.193.72/post"
}

Risoluzione dei problemi

Se riscontri problemi durante l'aggiornamento e l'estensione dei criteri di gestione delle API utilizzati con APIM Operator, consulta la sezione Risolvere i problemi di APIM Operator per trovare soluzioni agli errori comuni.

Passaggi successivi

Scopri come disinstallare l'operatore APIM di Apigee per Kubernetes.
Scopri di più sulle opzioni per il deployment dei gateway.