Questa pagina è stata tradotta dall'API Cloud Translation.

Inizia a utilizzare il Processore delle estensioni Apigee

Questa pagina si applica ad Apigee e Apigee hybrid.

Visualizza la documentazione di Apigee Edge.

Questa pagina descrive come configurare il processore di estensioni Apigee per abilitare l'applicazione dei criteri API per il traffico API utilizzando un bilanciatore del carico abilitato per le estensioni di servizio.

Per scoprire di più sui casi d'uso suggeriti e sui vantaggi dell'utilizzo di Apigee Extension Processor per la gestione delle API, consulta la panoramica di Apigee Extension Processor.

Il processore di estensioni Apigee è un' estensione del traffico (un tipo di Service Extension) che consente di utilizzare Cloud Load Balancing per inviare callout dal percorso di elaborazione dei dati del bilanciamento del carico delle applicazioni al processore di estensioni Apigee. Una volta configurati il bilanciatore del carico e l'estensione del traffico, il traffico API viene elaborato dal bilanciatore del carico. Le policy nel processore di estensioni Apigee vengono applicate al traffico API utilizzando i callout delle estensioni di traffico.

Le sezioni seguenti ti guidano attraverso i passaggi necessari per configurare gli elementi chiave del processore di estensioni Apigee:

Configura un bilanciatore del carico per un servizio di backend.

Configura il processore di estensioni Apigee.

Configura l'estensione del traffico.

Utilizza i criteri con Extension Processor.

Prima di iniziare

Prima di iniziare a configurare il processore di estensioni Apigee, assicurati di completare le seguenti attività:

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Apigee, Compute Engine, and Network Services APIs.

Enable the APIs

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Enable the Apigee, Compute Engine, and Network Services APIs.

Enable the APIs

Installa Google Cloud CLI.

Dopo aver installato Google Cloud CLI, esegui il comando gcloud components update per ottenere i componenti gcloud più recenti.
Esegui il provisioning di un'istanza Apigee utilizzando la versione 1-15-0-apigee-2 o successive, se non l'hai già fatto.
Puoi visualizzare le versioni dell'istanza nella pagina Dettagli istanza dell'interfaccia utente Apigee nella console Google Cloud . Vai alla pagina Istanze nella console Google Cloud per selezionare un'istanza e visualizzarne i dettagli:
Vai a Istanze

Puoi utilizzare Extension Processor con un'organizzazione Apigee con abbonamento o Pay-as-you-go. Se non sai se stai utilizzando un'organizzazione Apigee con abbonamento o con pagamento a consumo, contatta l'amministratore dell'organizzazione Apigee. Per maggiori dettagli sul provisioning delle istanze Apigee a pagamento, consulta Prima di iniziare.
Verifica di aver attivato una VPC e una subnet nell'istanza Apigee che prevedi di utilizzare. Vai alla pagina Reti VPC nella console Google Cloud :
Vai a Reti VPC

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per installare il processore di estensioni Apigee, 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 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 risorse di rete: Compute Network Admin (roles/compute.networkAdmin)
Crea e gestisci i servizi di backend: Amministratore bilanciatore del carico Compute (roles/compute.loadBalancerAdmin)
Crea e gestisci risorse Apigee: Apigee Org 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 i ruoli personalizzati o altri ruoli predefiniti.

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 ORG_NAME=$PROJECT_ID
export REGION=REGION
export INSTANCE=INSTANCE
export VPC_NETWORK_NAME=VPC_NETWORK_NAME
export SUBNET=SUBNET

Dove:

PROJECT_ID è l'ID del progetto con la tua istanza Apigee.
REGION è la regione Google Cloud della tua istanza Apigee.
INSTANCE è il nome della tua istanza Apigee.
VPC_NETWORK_NAME è il nome della rete VPC nel tuo progetto Google Cloud che vuoi utilizzare per il processore di estensioni Apigee.
SUBNET è il nome della subnet nel tuo progetto Google Cloud che vuoi utilizzare per il processore di estensioni Apigee.

Per verificare che le variabili di ambiente siano impostate correttamente, esegui il comando seguente ed esamina l'output:

echo $PROJECT_ID $ORG_NAME $REGION $INSTANCE $VPC_NETWORK_NAME $SUBNET

Configura un token di autenticazione

Per configurare un token di autenticazione, esegui questo comando:

export TOKEN=$(gcloud auth print-access-token)
echo $TOKEN

Configura un bilanciatore del carico per un servizio di backend

Le sezioni seguenti descrivono i passaggi necessari per configurare un bilanciatore del carico delle applicazioni esterno globale per un servizio di backend, utilizzando httpbin.org come esempio:

Crea un bilanciatore del carico delle applicazioni esterno globale.
Crea un gruppo di endpoint di rete (NEG).
Crea un servizio di backend.
Crea una mappa URL.
Crea un proxy di destinazione.
Crea una regola di forwarding globale.

Crea un bilanciatore del carico delle applicazioni esterno globale

Per creare il bilanciatore del carico:

Imposta la configurazione di gcloud in modo da utilizzare il progetto corrente:
```
gcloud config set project PROJECT_ID
```
Dove PROJECT_ID è l'ID del progetto con la tua istanza Apigee.
Crea un indirizzo IP statico globale:
```
gcloud compute addresses create IP_ADDRESS --ip-version=IPV4 --global
```
Dove IP_ADDRESS è il nome dell'indirizzo IP che vuoi creare. Il nome deve corrispondere all'espressione regolare (?:a-z?).
Ottieni l'indirizzo IP e salvalo come variabile di ambiente:
```
IP=$(gcloud compute addresses describe IP_ADDRESS --format="get(address)" --global)
```
dove IP_ADDRESS è il nome dell'indirizzo IP che hai creato nel passaggio precedente.
Crea un certificato TLS per nip.io, un servizio di terze parti che fornisce record DNS jolly per gli indirizzi IP:
```
gcloud compute ssl-certificates create SSL_CERT_NAME \
  --domains="nip.io"
```
Dove SSL_CERT_NAME è il nome del certificato che vuoi creare.

Crea un gruppo di endpoint di rete (NEG)

Per creare il gruppo di endpoint di rete (NEG) per il bilanciatore del carico:

Crea un NEG:

gcloud compute network-endpoint-groups create NEG_NAME \
  --network-endpoint-type=INTERNET_FQDN_PORT \
  --default-port=443 \
  --global

dove NEG_NAME è il nome del NEG che vuoi creare.

Aggiungi l'endpoint per httpbin.org al NEG:

gcloud compute network-endpoint-groups update NEG_NAME \
  --add-endpoint=fqdn=httpbin.org,port=443 \
  --global

dove NEG_NAME è il nome del NEG creato nel passaggio precedente.

Crea un servizio di backend

Per creare il servizio di backend esposto dal bilanciatore del carico:

Crea il servizio di backend:

gcloud compute backend-services create BACKEND_SERVICE_NAME \
  --load-balancing-scheme=EXTERNAL_MANAGED \
  --protocol=HTTPS \
  --global

Dove BACKEND_SERVICE_NAME è il nome del servizio di backend che vuoi creare.

Aggiungi il NEG al backend:
```
gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
  --network-endpoint-group=NEG_NAME \
  --global-network-endpoint-group \
  --global
```
Dove:
- BACKEND_SERVICE_NAME è il nome del servizio di backend che hai creato nel passaggio precedente.
- NEG_NAME è il nome del NEG che hai creato in un passaggio precedente.

Crea una mappa URL

Per creare una mappa URL tra il bilanciatore del carico e il servizio di backend, utilizza questo comando:

gcloud compute url-maps create URL_MAP_NAME \
  --default-service BACKEND_SERVICE_NAME \
  --global

Dove:

URL_MAP_NAME è il nome della mappa URL che vuoi creare.
BACKEND_SERVICE_NAME è il nome del servizio di backend che hai creato in un passaggio precedente.

Crea un proxy di destinazione

Per creare un proxy di destinazione per il bilanciatore del carico, utilizza il seguente comando:

gcloud compute target-https-proxies create TARGET_PROXY_NAME \
  --global \
  --ssl-certificates SSL_CERT_NAME \
  --global-ssl-certificates \
  --url-map URL_MAP_NAME \
  --global-url-map

Dove:

TARGET_PROXY_NAME è il nome del proxy di destinazione che vuoi creare.
URL_MAP_NAME è il nome della mappa URL che hai creato in un passaggio precedente.
SSL_CERT_NAME è il nome del certificato SSL creato per nip.io in un passaggio precedente.

Crea una regola di forwarding globale

Per creare una regola di forwarding globale per il bilanciatore del carico, utilizza il seguente comando:

gcloud compute forwarding-rules create FORWARDING_RULE_NAME \
  --load-balancing-scheme=EXTERNAL_MANAGED \
  --network-tier=PREMIUM \
  --address=IP_ADDRESS \
  --target-https-proxy=TARGET_PROXY_NAME \
  --ports=443 \
  --global

Dove:

FORWARDING_RULE_NAME è il nome della regola di forwarding che vuoi creare.
IP_ADDRESS è il nome dell'indirizzo IP dell'endpoint NEG che hai creato in un passaggio precedente.
TARGET_PROXY_NAME è il nome del proxy di destinazione che hai creato in un passaggio precedente.

Configura il processore di estensioni Apigee

Le sezioni seguenti descrivono i passaggi necessari per configurare il processore di estensioni Apigee:

Crea un ambiente Apigee.
Crea il proxy del processore di estensioni.

Crea un ambiente Apigee

Crea un ambiente Apigee utilizzando il seguente comando:

curl -i -X POST -H  "Authorization: Bearer $TOKEN" \
    "https://apigee.googleapis.com/v1/organizations/$ORG_NAME/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 che stai creando. Il nome deve contenere tra 2 e 32 caratteri, che possono essere lettere minuscole, numeri o trattini. Il nome deve iniziare con una lettera e non può terminare con un trattino. Il nome deve essere diverso da qualsiasi altro nome di ambiente nella tua organizzazione.

Verifica che l'ambiente sia stato creato:

curl -i -H "Authorization: Bearer $TOKEN" \
    "https://apigee.googleapis.com/v1/organizations/$ORG_NAME/environments"

L'elenco degli ambienti dovrebbe includere quello appena creato.

Collega l'ambiente appena creato alla tua istanza Apigee:

curl -i -X POST -H "Authorization: Bearer $TOKEN" \
    "https://apigee.googleapis.com/v1/organizations/$ORG_NAME/instances/$INSTANCE/attachments" -H "Content-Type:application/json" -d \
    '{
        "environment": "ENV_NAME"
        }'

dove ENV_NAME è il nome dell'ambiente che hai creato nel passaggio precedente.

Questa operazione potrebbe richiedere fino a 10 minuti.

Crea il gruppo di ambienti Apigee:

curl -H "Authorization: Bearer $TOKEN" -X POST \
    "https://apigee.googleapis.com/v1/organizations/$ORG_NAME/envgroups" -H "Content-Type:application/json" -d \
    '{
        "name": "ENV_GROUP_NAME",
        "hostnames": ["ENV_GROUP_HOSTNAME"]
        }'

Dove:

ENV_GROUP_NAME è il nome del gruppo di ambienti che stai creando.
ENV_GROUP_HOSTNAME è il nome host del gruppo di ambienti che stai creando. Il nome host deve essere un nome di dominio completo (FQDN).
Nota:il nome host non deve essere risolvibile.

Collega il nuovo ambiente al nuovo gruppo di ambienti:

curl -H "Authorization: Bearer $TOKEN" -X POST\
    "https://apigee.googleapis.com/v1/organizations/$ORG_NAME/envgroups/ENV_GROUP_NAME/attachments" -H "content-type:application/json" -d \
        '{
            "name": "ENV_GROUP_NAME",
            "environment": "ENV_NAME"
        }'

Dove:

ENV_GROUP_NAME è il nome del gruppo di ambienti che stai creando.
ENV_NAME è il nome dell'ambiente che hai creato in un passaggio precedente.

Crea il proxy del processore di estensioni

Per creare un proxy API Apigee senza target da utilizzare con il bilanciatore del carico del processore di estensioni:

Segui i passaggi descritti in Creazione di un proxy API per creare un proxy Nessun target con le seguenti specifiche:

Modello proxy: seleziona Nessun target.
Nome proxy: inserisci un nome proxy.
Percorso di base: imposta il percorso di base che preferisci. Il percorso non verrà utilizzato.

La specifica XML per il proxy dovrebbe essere simile alla seguente:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<APIProxy revision="1" name="extproc-sample">
    <DisplayName/>
    <Description/>
    <CreatedAt>1739581781912</CreatedAt>
    <LastModifiedAt>1739582447868</LastModifiedAt>
    <BasePaths>/</BasePaths>
    <Policies></Policies>
    <ProxyEndpoints>
        <ProxyEndpoint>default</ProxyEndpoint>
    </ProxyEndpoints>
</APIProxy>

Segui i passaggi descritti in Eseguire il deployment di un proxy API per eseguire il deployment del proxy nell'ambiente creato in precedenza.

Configurare l'estensione del traffico

Questa sezione descrive come configurare l'estensione del servizio di gestione del traffico per Extension Processor utilizzando i seguenti passaggi:

Crea un gruppo di endpoint di rete Private Service Connect Apigee.
Crea un'estensione di servizio del bilanciatore del carico.
Invia una richiesta al bilanciatore del carico.

Crea un gruppo di endpoint di rete Private Service Connect Apigee

In questa sezione creerai un gruppo di endpoint di rete (NEG) Private Service Connect (PSC) Apigee utilizzato per connetterti alla tua istanza Apigee. Per scoprire di più su PSC, consulta Pattern di rete southbound.

Nota: il comando per ottenere l'allegato di servizio PSC Apigee richiede jq. Se questa utilità di elaborazione JSON non è già installata nel tuo ambiente di sviluppo, puoi installarla utilizzando il seguente comando: $ sudo apt install jq.

Per creare un NEG PSC Apigee:

Recupera il collegamento del servizio PSC Apigee:

PSC_ATTACHMENT=$(curl -s -H "Authorization: Bearer $TOKEN" \
    "https://apigee.googleapis.com/v1/organizations/$ORG_NAME/instances" \
    | jq -r '.instances[] | select(.name = "'$INSTANCE'") | .serviceAttachment' \
    )

Per visualizzare il collegamento del servizio:

echo $PSC_ATTACHMENT

La risposta dovrebbe essere simile alla seguente:

projects/apigee-psc-autopush/regions/us-west1/serviceAttachments/apigee-us-west1-1234567890-psc-service-attachment

Crea il NEG PSC nella stessa regione dell'istanza Apigee:

gcloud compute network-endpoint-groups create apigee-neg-$REGION \
  --network-endpoint-type=private-service-connect \
  --psc-target-service=$PSC_ATTACHMENT \
  --region=$REGION \
  --network=$VPC_NETWORK_NAME \
  --subnet=$SUBNET

La risposta dovrebbe essere simile alla seguente:

projects/ab123456cd78ef910g-tp/regions/asia-northeast1/serviceAttachments/apigee-asia-northeast1-abcd

Crea un servizio di backend HTTP/2 che rimandi al NEG PSC, se non ne esiste già uno:
```
gcloud compute backend-services create PSC_NEG_BACKEND_SERVICE \
  --load-balancing-scheme=EXTERNAL_MANAGED \
  --protocol=HTTP2 \
  --global
```
Dove PSC_NEG_BACKEND_SERVICE è il nome del servizio di backend che vuoi creare.

Aggiungi il servizio di backend NEG PSC:

gcloud compute backend-services add-backend PSC_NEG_BACKEND_SERVICE \
  --network-endpoint-group=apigee-neg-$REGION \
  --network-endpoint-group-region=$REGION \
  --global

dove PSC_NEG_BACKEND_SERVICE è il nome del servizio di backend creato in un passaggio precedente.

Abilita il logging per il servizio di backend:

gcloud compute backend-services update PSC_NEG_BACKEND_SERVICE \
  --global \
  --enable-logging \
  --logging-sample-rate=1.0

dove PSC_NEG_BACKEND_SERVICE è il nome del servizio di backend creato in un passaggio precedente.

Crea un'estensione di servizio del bilanciatore del carico

Quando crei un'estensione del servizio di bilanciamento del carico, puoi personalizzare il comportamento del proxy del processore dell'estensione modificando i valori di vari campi che descrivono l'estensione, come mostrato nella tabella seguente:

Trattamento del corpo Eventi supportati Metadati Modalità di invio

Elaborazione del corpo di richiesta e risposta

Trattamento del corpo	Eventi supportati	Metadati	Modalità di invio
Elaborazione del corpo di richiesta e risposta	`REQUEST_HEADERS` `REQUEST_BODY` `REQUEST_TRAILERS` `RESPONSE_HEADERS` `RESPONSE_BODY` `RESPONSE_TRAILERS`	`apigee-request-body: true` `apigee-response-body: true`	`requestBodySendMode: BODY_SEND_MODE_FULL_DUPLEX_STREAMED` `responseBodySendMode: BODY_SEND_MODE_FULL_DUPLEX_STREAMED`
Elaborazione solo del corpo della richiesta	`REQUEST_HEADERS` `REQUEST_BODY` `REQUEST_TRAILERS` `RESPONSE_HEADERS`	`apigee-request-body: true`	`requestBodySendMode: BODY_SEND_MODE_FULL_DUPLEX_STREAMED`
Elaborazione solo del corpo della risposta	`REQUEST_HEADERS` `RESPONSE_HEADERS` `RESPONSE_BODY` `RESPONSE_TRAILERS`	`apigee-response-body: true`	`responseBodySendMode: BODY_SEND_MODE_FULL_DUPLEX_STREAMED`

REQUEST_HEADERS

REQUEST_BODY

REQUEST_TRAILERS

RESPONSE_HEADERS

RESPONSE_BODY

RESPONSE_TRAILERS

apigee-request-body: true

apigee-response-body: true

requestBodySendMode: BODY_SEND_MODE_FULL_DUPLEX_STREAMED

responseBodySendMode: BODY_SEND_MODE_FULL_DUPLEX_STREAMED

Elaborazione solo del corpo della richiesta

REQUEST_HEADERS

REQUEST_BODY

REQUEST_TRAILERS

RESPONSE_HEADERS

apigee-request-body: true

requestBodySendMode: BODY_SEND_MODE_FULL_DUPLEX_STREAMED

Elaborazione solo del corpo della risposta

REQUEST_HEADERS

RESPONSE_HEADERS

RESPONSE_BODY

RESPONSE_TRAILERS

apigee-response-body: true

responseBodySendMode: BODY_SEND_MODE_FULL_DUPLEX_STREAMED

In questo passaggio, creerai un'estensione del servizio di bilanciatore del carico che supporta l'elaborazione del corpo della richiesta e della risposta:

curl -X POST "https://networkservices.googleapis.com/v1beta1/projects/$PROJECT_ID/locations/global/lbTrafficExtensions?lbTrafficExtensionId=global-xlb-httpbin-apim-policy" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "global-xlb-httpbin-apim-policy",
    "forwardingRules": [
        "https://www.googleapis.com/compute/v1/projects/$PROJECT_ID/global/forwardingRules/FORWARDING_RULE_NAME"
    ],
    "extensionChains": [
        {
            "name": "httpbin-apigee-extension-chain",
            "matchCondition": {
                "celExpression": "true"
            },
            "extensions": [
                {
                    "name": "httpbin-apigee-extension",
                    "authority": "ENV_GROUP_HOSTNAME",
                    "service": "https://www.googleapis.com/compute/v1/projects/$PROJECT_ID/global/backendServices/PSC_NEG_BACKEND_SERVICE",
                    "supportedEvents": [
                        "REQUEST_HEADERS",
                        "REQUEST_BODY",
                        "REQUEST_TRAILERS",
                        "RESPONSE_HEADERS",
                        "RESPONSE_BODY",
                        "RESPONSE_TRAILERS"
                    ],
                    "timeout": "1s",
                    "requestBodySendMode": "BODY_SEND_MODE_FULL_DUPLEX_STREAMED",
                    "responseBodySendMode": "BODY_SEND_MODE_FULL_DUPLEX_STREAMED"
                }
            ]
        }
    ],
    "loadBalancingScheme": "EXTERNAL_MANAGED",
    "metadata": {
        "apigee-extension-processor": "EXT_PROC_NAME",
        "apigee-request-body": "true",
        "apigee-response-body": "true"
    }
}'

Dove:

EXT_PROC_NAME Questo nome deve corrispondere a quello del proxy API creato in un passaggio precedente.
FORWARDING_RULE_NAME è il nome della regola di forwarding che hai creato in un passaggio precedente.
ENV_GROUP_HOSTNAME è il nome di dominio utilizzato per il gruppo di ambienti.
PSC_NEG_BACKEND_SERVICE è il nome del servizio di backend che hai creato in un passaggio precedente.

Il completamento dell'operazione potrebbe richiedere alcuni minuti.

Per confermare la creazione dell'estensione di servizio, utilizza questo comando:

curl "https://networkservices.googleapis.com/v1beta1/projects/$PROJECT_ID/locations/global/lbTrafficExtensions/httpbin-apigee-extension" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json"

La risposta dovrebbe essere simile alla seguente e mostrare la regola di forwarding e il servizio di backend:

createTime: '2025-03-22T00:29:16.056719825Z'
extensionChains:
- extensions:
  - authority: extension-processor-test.hybrid.e2e.apigeeks.net
    name: httpbin-apigee-extension
    service: https://www.googleapis.com/compute/v1/projects/123456789012/global/backendServices/ep-test-psc-neg-bes
    supportedEvents:
    - REQUEST_HEADERS
    - REQUEST_BODY
    - REQUEST_TRAILERS
    - RESPONSE_HEADERS
    - RESPONSE_BODY
    - RESPONSE_TRAILERS
    timeout: 1s
  matchCondition:
    celExpression: 'true'
  name: httpbin-apigee-extension-chain
forwardingRules:
- https://www.googleapis.com/compute/v1/projects/123456789012/global/forwardingRules/ep-test-fw-rule
loadBalancingScheme: EXTERNAL_MANAGED
metadata:
  apigee-extension-processor: ep-test-proxy
  apigee-request-body: true
  apigee-response-body: true
name: projects/extension-processor-test/locations/global/lbTrafficExtensions/global-xlb-httpbin-apim-policy
updateTime: '2025-03-22T00:29:31.183275055Z'

Invia una richiesta al bilanciatore del carico

Per testare la configurazione del bilanciatore del carico e del processore delle estensioni, invia una richiesta al bilanciatore del carico:

curl "https://LB_DOMAIN_NAME/get"

dove LB_DOMAIN_NAME è il nome di dominio che hai utilizzato per il bilanciatore del carico e il certificato SSL. Se hai utilizzato nip.io, il nome di dominio sarà simile a IP_ADDRESS.nip.io.

La risposta dovrebbe essere simile alla seguente:

{"status": 200,
  {
    "args": {},
    "headers": {
      ...
    },
    "origin": "173.93.50.108",
    "url": "https://httpbin.org/get"
  }
}

Utilizzare i criteri con Extension Processor

Questa sezione descrive come utilizzare i criteri con Extension Processor.

In questo esempio, per l'Extension Processor sono configurati i criteri VerifyAPIkey e AssignMessage. Queste norme vengono utilizzate per convalidare le chiavi API incluse nelle richieste ad Apigee e inserire un token Google nelle intestazioni delle richieste per le chiamate a un servizio di backend. Questo scenario sarebbe utile per i fornitori di API che utilizzano il processore di estensioni Apigee per autorizzare e autenticare le richieste ai propri servizi Apigee e inserire senza problemi i token di autenticazione richiesti per un servizio di backend come Vertex AI.Google

Aggiungi il criterio VerifyAPIKey per la convalida delle chiavi API

Le sezioni seguenti descrivono come utilizzare il criterio VerifyAPIKey per convalidare le chiavi API per le chiamate al servizio di backend utilizzando Extension Processor:

Allega la policy VerifyAPIKey al processore di estensioni.
Crea un prodotto API.
Crea un'app sviluppatore e le relative credenziali.
Invia una richiesta al bilanciatore del carico utilizzando la chiave API.

Collega il criterio VerifyAPIKey al proxy

Per collegare una norma VerifyAPIKey al proxy del processore di estensioni:

Nell'interfaccia utente Apigee nella console Cloud, vai alla scheda Sviluppa e seleziona il proxy del processore di estensioni creato in un passaggio precedente.
Nella sezione Norme, fai clic su + Aggiungi norma.
Nel riquadro Aggiungi policy, seleziona VerifyAPIKey dall'elenco delle policy.
Nel riquadro VerifyAPIKey, completa i campi obbligatori nelle sezioni Nome criterio e Nome visualizzato utilizzando i seguenti valori:
- Nome della policy: inserisci un nome per la policy. Ad esempio, VA-verify-api-key.
- Nome visualizzato: inserisci il nome della policy da utilizzare nell'interfaccia utente. Ad esempio, VA-verify-api-key.

Fai clic su Crea.

La specifica XML per il criterio VerifyAPIKey incluso nel proxy del processore di estensioni dovrebbe essere simile alla seguente:

  <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
  <VerifyAPIKey continueOnError="false" enabled="true" name="VA-verify-api-key">
    <DisplayName>VA-verify-api-key</DisplayName>
    <Properties/>
    <APIKey ref="request.queryparam.x-api-key"/>
  </VerifyAPIKey>

Esegui il deployment della nuova revisione del proxy.

Crea un prodotto API

Per creare un prodotto API e configurare il set di operazioni API per il tuo servizio:

Segui i passaggi descritti in Creazione di un prodotto API per creare un prodotto API per il tuo servizio. Puoi configurare i dettagli del prodotto per il prodotto API come preferisci.
Segui i passaggi descritti in Operazioni per aggiungere un insieme di operazioni API al prodotto API, in base alle seguenti specifiche:
- Origine: scegli Proxy API e seleziona il proxy che hai creato in un passaggio precedente.
- Operazione: configura i seguenti percorsi e metodi:
  - Percorso: /get con metodo: GET
  - Percorso: /PROXY_NAME con metodo: GET
    PROXY_NAME è il nome del proxy che hai creato in un passaggio precedente.

Creare un'app sviluppatore e le relative credenziali

Per creare un'app sviluppatore e le relative credenziali per il prodotto API appena creato:

Vai alla pagina Gestione API Apigee nella console Google Cloud :
Gestione delle API Apigee
Crea uno sviluppatore:
1. Seleziona Distribuzione > Sviluppatori.
2. Nella pagina Sviluppatori, fai clic su + Crea.
3. Nella pagina Aggiungi sviluppatore, compila i campi obbligatori utilizzando i valori che preferisci.
4. Fai clic su Aggiungi.
Crea un'app:
1. Seleziona Distribuzione> App.
2. Nella pagina App, fai clic su + Crea.
3. Nella pagina Crea app, compila i campi obbligatori nella sezione Dettagli app utilizzando i seguenti valori:
  - Nome app: inserisci un nome per l'app. Ad esempio, ext-proc-app
  - Sviluppatore: seleziona lo sviluppatore che hai creato nel passaggio precedente o un altro sviluppatore dall'elenco.
4. Nella sezione Credenziali app, fai clic su + Aggiungi credenziale.
5. Nella sezione Credenziali, seleziona Mai dalla casella di elenco Scadenza.
6. Nella sezione Prodotti, fai clic su + Aggiungi prodotti per visualizzare il riquadro Aggiungi prodotti.
7. Seleziona il prodotto API che hai creato nel passaggio precedente.
8. Fai clic su OK.
9. Fai clic su Aggiungi per chiudere il riquadro Aggiungi prodotti.
10. Fai clic su Crea.
Nella pagina Dettagli app, nella sezione Credenziali, fai clic su per visualizzare il valore della chiave.
Copia il valore di Key. Utilizzerai questa chiave per effettuare chiamate API al tuo servizio in un passaggio successivo.
Nella pagina Dettagli app, nella sezione Credenziali, fai clic su per visualizzare il valore di Secret app.

Invia una richiesta al bilanciatore del carico utilizzando la chiave API

Per testare la convalida della chiave API, invia una richiesta al bilanciatore del carico utilizzando la chiave API:

curl "https://LB_DOMAIN_NAME/get"

dove LB_DOMAIN_NAME è il nome di dominio che hai utilizzato per il bilanciatore del carico e il certificato SSL.

La risposta dovrebbe non andare a buon fine senza una chiave API.

Invia un'altra richiesta al bilanciatore del carico, utilizzando la chiave API nella richiesta:

curl "https://LB_DOMAIN_NAME/get?key=API_KEY"

Dove:

LB_DOMAIN_NAME è il nome di dominio che hai utilizzato per il bilanciatore del carico e il certificato SSL.
API_KEY è la chiave API delle credenziali dell'app per sviluppatori mostrate in un passaggio precedente.

La risposta dovrebbe indicare l'autorizzazione riuscita per l'endpoint. Ciò indica che Extension Processor ha convalidato la chiave API e la richiesta ora può essere elaborata dal proxy Apigee.

Aggiungi la policy AssignMessage per l'autenticazione Google

Se vuoi utilizzare il tuo processore di estensioni per fornire la gestione delle API per un servizio autenticato da Google, puoi inserire un token di accesso Google o un token ID Google nelle richieste inviate al servizio di backend utilizzando il criterio AssignMessage.

Le sezioni seguenti descrivono come utilizzare il criterio AssignMessage per inserire un token di autenticazione nelle richieste inviate al servizio di backend utilizzando il processore di estensioni: Google

Collega la policy AssignMessage al proxy.
Invia una richiesta al bilanciatore del carico per testare l'inserimento del token.

Collega il criterio AssignMessage al proxy

Per aggiungere la norma AssignMessage al proxy:

Nell'interfaccia utente Apigee nella console Cloud, vai alla scheda Sviluppa e seleziona il proxy creato in un passaggio precedente.
Nella sezione Norme, fai clic su + Aggiungi norma.
Nel riquadro Aggiungi norma, seleziona Assegna messaggio dall'elenco delle norme.
Nel riquadro Assegna messaggio, compila i campi obbligatori nelle sezioni Nome criterio e Nome visualizzato utilizzando i seguenti valori:
- Nome della policy: inserisci un nome per la policy. Ad esempio, AM-auth.
- Nome visualizzato: inserisci un nome della policy da visualizzare nell'interfaccia utente. Ad esempio, AM-auth.
Fai clic su Crea.

Sotto l'elemento <Set>, aggiungi i seguenti elementi secondari:

<Set>
    <Authentication>
    <HeaderName>Authorization</HeaderName>
    <GoogleAccessToken>
        <Scopes>
        <Scope>https://www.googleapis.com/auth/cloud-platform</Scope>
        </Scopes>
    </GoogleAccessToken>
    </Authentication>
</Set>

Fai clic su Salva.
Esegui il deployment della nuova revisione utilizzando un service account Google .

Il account di servizio viene utilizzato per generare Google token di accesso e inserirli nell'intestazione della richiesta per le chiamate API ai servizi di backend Google .

Invia una richiesta al bilanciatore del carico per testare l'inserimento del token

Per verificare che l'inserimento del token funzioni, invia una richiesta al bilanciatore del carico:

curl "https://LB_DOMAIN_NAME/get"

dove LB_DOMAIN_NAME è il nome di dominio che hai utilizzato per il bilanciatore del carico e il certificato SSL.

La risposta dovrebbe essere simile alla seguente:

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

La risposta deve mostrare l'inserimento riuscito del token di autenticazione Google nell'intestazione della richiesta.

Con l'applicazione riuscita del criterio AssignMessage, la richiesta riuscita del client (contenente la chiave API) ad Apigee nello scenario di esempio viene ulteriormente modificata per includere un token di autenticazione Google nell'intestazione della richiesta, come richiesto dal servizio di backend autenticato con Google.

Inizia a utilizzare il Processore delle estensioni Apigee Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Prima di iniziare

Ruoli obbligatori

Imposta le variabili di ambiente

Configura un token di autenticazione

Configura un bilanciatore del carico per un servizio di backend

Crea un bilanciatore del carico delle applicazioni esterno globale

Crea un gruppo di endpoint di rete (NEG)

Crea un servizio di backend

Crea una mappa URL

Crea un proxy di destinazione

Crea una regola di forwarding globale

Configura il processore di estensioni Apigee

Crea un ambiente Apigee

Crea il proxy del processore di estensioni

Configurare l'estensione del traffico

Crea un gruppo di endpoint di rete Private Service Connect Apigee

Crea un'estensione di servizio del bilanciatore del carico

Invia una richiesta al bilanciatore del carico

Utilizzare i criteri con Extension Processor

Aggiungi il criterio VerifyAPIKey per la convalida delle chiavi API

Collega il criterio VerifyAPIKey al proxy

Crea un prodotto API

Creare un'app sviluppatore e le relative credenziali

Invia una richiesta al bilanciatore del carico utilizzando la chiave API

Aggiungi la policy AssignMessage per l'autenticazione Google

Collega il criterio AssignMessage al proxy

Invia una richiesta al bilanciatore del carico per testare l'inserimento del token

Inizia a utilizzare il Processore delle estensioni Apigee