Questa pagina è stata tradotta dall'API Cloud Translation.

Aggiungi criteri al gateway GKE

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

Visualizza la documentazione di Apigee Edge.

Questa pagina descrive come aggiungere i criteri di runtime di Apigee e un Google criterio di inserimento di token al gateway Google Kubernetes Engine (GKE) con l'operatore APIM di Apigee per Kubernetes (anteprima). L'aggiunta di un insieme di criteri disponibili a Gateway ti consente di estendere la funzionalità di Gateway oltre l'applicazione dei prodotti API per includere ulteriori regole di sicurezza e aziendali.

L'operatore APIM di Apigee per Kubernetes può essere utilizzato per aggiungere i seguenti criteri al gateway:

Panoramica

Le sezioni seguenti descrivono come:

Aggiungi criteri al gateway GKE.
Crea una regola modello per applicare l'utilizzo dei criteri.
Aggiorna il modello Apigee in modo da includere la regola del modello .

Esegui il deployment del criterio Apigee Gateway con il modello.
Convalida l'applicazione delle norme.

Prima di iniziare

Per modificare il tuo gateway GKE con il set completo di criteri utilizzato come esempio in questa guida, devi disporre di un account di servizio con i ruoli necessari per creare token in Apigee e implementare proxy ed estensioni. Se scegli di non creare Google token, non devi aggiungere i ruoli aggiuntivi al tuo account di servizio e puoi saltare alla sezione successiva.

Per creare un account di servizio con le autorizzazioni richieste:

Se hai creato un account di servizio denominato apigee-apim-gsa nella guida all'installazione di Apigee APIM Operator for Kubernetes, puoi saltare questo passaggio e andare al successivo. In caso contrario, crea l'account di servizio:
```
gcloud iam service-accounts create apigee-apim-gsa --project=${PROJECT_ID}
```

Concedi all'account di servizio il ruolo necessario per creare token:

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

Concedi all'account di servizio apigee-apim-gsa il ruolo necessario per il deployment di proxy ed estensioni:

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

Modificare il gateway GKE con i criteri

Puoi scegliere di modificare GKE Gateway con uno o più criteri per estenderne la funzionalità. Questo walkthrough di esempio applica al gateway un file yaml che include le specifiche di due criteri Apigee e un criterio di Google iniezione di token.

Ognuna delle norme applicate al gateway utilizzando il seguente file yaml svolge un ruolo diverso durante la valutazione delle richieste inviate al gateway:

Il criterio SpikeArrest controlla la frequenza di picco dei messaggi definendo una frequenza massima di richieste consentite in un'unità di tempo. In questo esempio, la frequenza massima è impostata su cinque al minuto. Per scoprire di più su come viene utilizzato il criterio SpikeArrest per attenuare i picchi improvvisi di traffico, consulta Criterio SpikeArrest.
Il criterio JavaScript ti consente di aggiungere codice JavaScript personalizzato alle richieste di Gateway. In questo esempio, il criterio viene utilizzato per aggiungere un'intestazione personalizzata alla richiesta. Per scoprire di più su come viene utilizzato il criterio JavaScript per aggiungere codice personalizzato, consulta la sezione Criterio JavaScript.
Il Google criterio di inserimento di token viene utilizzato per inserire un Google token di accesso all'autenticazione nelle richieste di gateway utilizzando il criterio Assegna messaggio. Apigee supporta l'utilizzo di Google token OAuth o token OpenID Connect per autenticarsi con i servizi Google . Per scoprire di più sui token di autenticazione, consulta Utilizzare l'autenticazione Google.

Aggiungi i criteri al gateway:

Crea un nuovo file denominato apigee-policies.yaml nello spazio dei nomi apim.

Copia i contenuti del seguente file nel nuovo file che hai creato:

# apigee-policies.yaml
apiVersion: apim.googleapis.com/v1alpha1
kind: SpikeArrest
metadata:
  name: spike-arrest
  namespace: apim
spec:
  identifier:
    ref: request.header.name
  useEffectiveCount: true
  peakMessageRate:
    value: "5pm"
---
apiVersion: apim.googleapis.com/v1alpha1
kind: Javascript
metadata:
  name: js-add-headers
  namespace: apim
spec:
  timeLimit: 2000
  source: |
    var sum = 1+1;
    context.setVariable("request.header.first", 1);
    context.setVariable("request.header.second", 1);
    context.setVariable("request.header.sum", sum);
---
apiVersion: apim.googleapis.com/v1alpha1
kind: AssignMessage
metadata:
  name: google-token-policy
  namespace: apim
spec:
  setActions:
    - authentication:
        googleAccessToken:
          scopes:
            - 'https://www.googleapis.com/auth/cloud-platform'
  AssignTo:
    createNew: false
    type: request

Applica il file yaml al gateway utilizzando il seguente comando:
```
kubectl -n apim apply -f apigee-policies.yaml
```

Creare una regola del modello come modello SharedFlow

In questo passaggio, creerai un TemplateRule per applicare i criteri che hai aggiunto al gateway. Una regola modello è una regola per i flussi condivisi creata dagli amministratori dell'organizzazione per garantire che gli sviluppatori di servizi applichino al traffico di Gateway solo i criteri approvati. Una regola del modello garantisce che gli sviluppatori comprendano quali criteri sono a loro disposizione, quali sono obbligatori per casi d'uso specifici e quali non possono essere utilizzati dagli sviluppatori di servizi.

Crea una regola del modello

Crea una regola del modello per applicare l'utilizzo del criterio Assegna messaggio:

Crea un nuovo file yaml denominato template-rule.yaml nello spazio dei nomi apim.
Copia i contenuti del seguente file nel nuovo file che hai creato:
```
# template-rule.yaml
apiVersion: apim.googleapis.com/v1alpha1
kind: ApimTemplateRule
metadata:
  name: template-rule
  namespace: apim
spec:
  allowList: [SpikeArrest, Javascript]
  requiredList: [AssignMessage]
  denyList: []
```
In questo esempio, la regola del modello indica agli sviluppatori che è obbligatorio il criterio AssignMessage che descrive il Google criterio di inserimento di token. Inoltre, comunica agli sviluppatori che possono utilizzare i criteri SpikeArrest e JavaScript nella gestione delle API. Non sono specificati criteri nell'elenco di rifiuto.

Applicare la regola del modello

Applica la regola del modello utilizzando il seguente comando:

kubectl apply -f template-rule.yaml

Aggiorna il modello Apigee in modo da includere le regole del modello

Aggiorna il modello Apigee in modo da includere la regola del modello creata nella sezione precedente:

Crea un nuovo file yaml denominato new-admin-template.yaml nello spazio dei nomi apim.

Copia i contenuti del seguente file nel nuovo file che hai creato:

# new-admin-template.yaml
apiVersion: apim.googleapis.com/v1alpha1
kind: ApimTemplate
metadata:
  name: new-admin-template
  namespace: apim
spec:
  apimTemplateRule:
    group: apim.googleapis.com
    kind: ApimTemplateRule
    name: template-rule
    namespace: apim
  templates:
  - policies:
      - group: apim.googleapis.com
        kind: SpikeArrest
        name: spike-arrest
        namespace: apim
      - group: apim.googleapis.com
        kind: Javascript
        name: js-add-headers
        namespace: apim
      - group: apim.googleapis.com
        kind: AssignMessage
        name: google-token-policy
        namespace: apim

Applica il modello aggiornato utilizzando il seguente comando:
```
kubectl apply -f new-admin-template.yaml
```

Esegui il deployment del criterio Apigee Gateway

In questo passaggio, dovrai applicare al tuo gateway un nuovo file che includa le specifiche di un ApigeeGatewayPolicy. Questo criterio viene utilizzato per eseguire il deployment del modello Apigee in Gateway.

Esegui il deployment del criterio Apigee Gateway:

Crea un nuovo file yaml denominato apigee-gateway-policy-withSA.yaml nello spazio dei nomi apim.

Copia i contenuti del seguente file nel nuovo file che hai creato:

# apigee-gateway-policy-withSA.yaml
apiVersion: apim.googleapis.com/v1alpha1
kind: ApigeeGatewayPolicy
metadata:
  name: apim-template-injection
  namespace: apim
spec:
  serviceAccount: apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com
  ref:
    group: apim.googleapis.com
    kind: ApimTemplate
    name: new-admin-template
    namespace: apim
  targetRef:
    group: apim.googleapis.com
    kind: APIMExtensionPolicy
    name: global-ext-lb1-apim-policy
    namespace: apim

Applica il criterio:

kubectl apply -f apigee-gateway-policy-withSA.yaml

Verifica lo stato di implementazione del nuovo criterio di gateway:
```
kubectl -n apim get ApigeeGatewayPolicy
```
Una volta implementato, il criterio STATUS dovrebbe mostrare CREATED.

Dopo aver eseguito il deployment del nuovo criterio del gateway, attendi due minuti prima di inviare una richiesta al gateway per consentire la propagazione del criterio al cluster.

Convalida l'applicazione dei criteri

Per verificare che le norme di Apigee Gateway funzionino come previsto, invia richieste al gateway come descritto nelle sezioni seguenti.

Verificare l'applicazione dei criteri di AssignMessage

Per verificare che il token {company_name} venga inserito nella richiesta utilizzando il criterio AssignMessage, invia una richiesta a Gateway utilizzando il seguente comando:

curl http://GATEWAY_IP_ADDRESS/get -H "Host: HOST_NAME" -H "x-api-key: API_KEY"

Dove:

GATEWAY_IP_ADDRESS è l'indirizzo IP del gateway. Puoi recuperare l'indirizzo IP del gateway utilizzando il seguente comando:
```
kubectl get gateway GATEWAY_NAME
```
HOST_NAME è il nome dell'host.
API_KEY è il valore della chiave API.

Una risposta corretta deve includere un'intestazione Authorization con il token bearer generato, simile alla seguente:

{
  "args": {}, 
  "headers": {
    "Accept": "*/*", 
    "Authorization": "Bearer ya29.c.c0ASRK0Gbw03y9cfvxL11DxaRYBQUU18SmUP4Vu63OckHI5cX7wJ4DmGMG2vbDDS69HXJHqMj-lak4tcqOsJGmE65crn2gNuJLanXidwM8", 
    "First": "1.0", 
    "Host": "apigee-apim-operator-test.apigee.net", 
    "Second": "1.0", 
    "Sum": "2", 
    "User-Agent": "curl/8.7.1", 
    "X-Api-Key": "McYcHGR3PTSGLXExvKADwQ1JJeCjgPDUvAakCl0rJKCFaX0Y", 
    "X-Cloud-Trace-Context": "0fd3dadc2a3c328fa968d5f5f1434c29/18300783092696918345"
  }, 
  "origin": "34.54.108.129", 
  "url": "apigee-apim-operator-test.apigee.net/get"
}

Conferma l'applicazione del criterio SpikeArrest

Puoi testare l'applicazione del criterio SpikeArrest inviando una richiesta al gateway dieci volte nell'arco di un minuto.

Per generare le richieste, puoi eseguire lo script seguente:

#!/bin/sh
for i in $(seq 1 11); do
    curl http://GATEWAY_IP_ADDRESS/get -H "Host: HOST_NAME" -H "x-api-key: API_KEY"
    sleep 1
done

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[0].value}"
```
HOST_NAME è il nome host definito in HTTPRoute del gateway.
API_KEY è il valore della chiave API ottenuto in Configurazione del test.

La risposta sarà simile alla seguente:

"fault":{"faultstring":"Spike arrest violation. Allowed rate : MessageRate{capacity=5, period=Minutes}","detail":{"errorcode":"policies.ratelimit.SpikeArrestViolation"}}}

Risoluzione dei problemi

Se riscontri problemi durante l'aggiunta di criteri a GKE Gateway, consulta Risolvere i problemi dell'operatore APIM per trovare le soluzioni agli errori più comuni.

Passaggi successivi

Scopri di più sul criterio SpikeArrest.
Scopri di più sulle norme relative a JavaScript.