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:

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:

  1. 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}
  2. 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"
  3. 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:

  1. Crea un nuovo file denominato apigee-policies.yaml nello spazio dei nomi apim.
  2. 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
      
  3. 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:

  1. Crea un nuovo file yaml denominato template-rule.yaml nello spazio dei nomi apim.
  2. 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:

  1. Crea un nuovo file yaml denominato new-admin-template.yaml nello spazio dei nomi apim.
  2. 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
  3. 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:

  1. Crea un nuovo file yaml denominato apigee-gateway-policy-withSA.yaml nello spazio dei nomi apim.
  2. 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
  3. Applica il criterio:
    kubectl apply -f apigee-gateway_policy_withSA.yaml
  4. 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 il criterio Apigee Gateway funzioni come previsto, invia una richiesta al gateway e verifica che il token Google venga inserito nella richiesta.

Invia una richiesta al gateway utilizzando il seguente comando:

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

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"
}

Risoluzione dei problemi

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

Passaggi successivi