Comece a usar o Apigee Extension Processor

Esta página aplica-se ao Apigee e ao Apigee Hybrid.

Veja a documentação do Apigee Edge.

Esta página descreve como configurar o processador de extensões do Apigee para ativar a aplicação de políticas de API para o tráfego de API através de um equilibrador de carga com extensões de serviço ativadas.

Para saber mais sobre os exemplos de utilização sugeridos e as vantagens de usar o Apigee Extension Processor para a gestão de APIs, consulte o artigo Vista geral do Apigee Extension Processor.

O processador de extensões do Apigee é uma extensão de tráfego (um tipo de extensão de serviço) que lhe permite usar o Cloud Load Balancing para enviar pedidos de chamadas do caminho de processamento de dados do equilibrador de carga de aplicações para o processador de extensões do Apigee. Assim que o equilibrador de carga e a extensão de tráfego estiverem configurados, o tráfego da API é processado pelo equilibrador de carga. As políticas no processador de extensões do Apigee são aplicadas ao tráfego da API através dos destaques de extensões de tráfego.

As secções seguintes explicam os passos necessários para configurar os elementos principais do Apigee Extension Processor:

  • Configure um balanceador de carga para um serviço de back-end.
  • Configure o processador de extensões do Apigee.
  • Configure a extensão de tráfego.
  • Use políticas com o processador de extensões.

    • Antes de começar

    Antes de começar a configurar o Apigee Extension Processor, certifique-se de que conclui as seguintes tarefas:

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

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

      Go to project selector

    3. Verify that billing is enabled for your Google Cloud project.

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

      Enable the APIs

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

      Go to project selector

    6. Verify that billing is enabled for your Google Cloud project.

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

      Enable the APIs

      8.

    8. Instale a CLI do Google Cloud.

      Depois de instalar a CLI gcloud, execute o comando gcloud components update para obter os componentes gcloud mais recentes.

    9. Aprovisione uma instância do Apigee com a versão 1-15-0-apigee-2 ou posterior, se ainda não o tiver feito.

      Pode ver as versões das instâncias na página Detalhes da instância da IU do Apigee na Google Cloud consola. Aceda à página Instâncias na Google Cloud consola para selecionar uma instância e ver os respetivos detalhes:

      Aceda a Instâncias

      Pode usar o processador de extensões com uma organização do Apigee de subscrição ou de Pay-as-you-go. Se não tiver a certeza de que está a usar uma organização do Apigee de subscrição ou de pagamento conforme o uso, contacte o administrador da sua organização do Apigee. Para mais detalhes sobre o aprovisionamento de instâncias pagas do Apigee, consulte o artigo Antes de começar.

    10. Confirme que tem uma VPC e uma sub-rede ativadas na instância do Apigee que planeia usar. Aceda à página Redes VPC na Google Cloud consola:

      Aceda a Redes VPC

      11. Funções necessárias

      Para receber as autorizações de que precisa para instalar o Apigee Extension Processor, peça ao seu administrador que lhe conceda as seguintes funções de IAM na organização:

      Para mais informações sobre a atribuição de funções, consulte o artigo Faça a gestão do acesso a projetos, pastas e organizações.

      Também pode conseguir as autorizações necessárias através de funções personalizadas ou outras funções predefinidas.

      Defina variáveis de ambiente

      No Google Cloud projeto que contém a sua instância do Apigee, use o seguinte comando para definir variáveis de 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

      Onde:

      • PROJECT_ID é o ID do projeto com a sua instância do Apigee.
      • REGION é a Google Cloud região da sua instância do Apigee.
      • INSTANCE é o nome da sua instância do Apigee.
      • VPC_NETWORK_NAME é o nome da rede VPC no seu projeto Google Cloud que quer usar para o processador de extensões do Apigee.
      • SUBNET é o nome da sub-rede no seu projeto Google Cloud que quer usar para o processador de extensões da Apigee.

      Para confirmar que as variáveis de ambiente estão definidas corretamente, execute o seguinte comando e reveja o resultado: 

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

      Configure um token de autenticação

      Para configurar um token de autenticação, execute o seguinte comando: 

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

      Configure um balanceador de carga para um serviço de back-end

      As secções seguintes descrevem os passos necessários para configurar um Application Load Balancer externo global para um serviço de back-end, usando httpbin.org como exemplo:

      1. Crie um Application Load Balancer externo global.
      2. Crie um grupo de pontos finais da rede (NEG).
      3. Crie um serviço de back-end.
      4. Crie um mapa de URLs.
      5. Crie um proxy de destino.
      6. Crie uma regra de encaminhamento global.

      Crie um balanceador de carga de aplicações externo global

      Para criar o balanceador de carga:

      1. Defina a configuração gcloud para usar o seu projeto atual: 
        gcloud config set project PROJECT_ID

        Onde PROJECT_ID é o ID do projeto com a sua instância do Apigee.

      2. Crie um endereço IP estático global: 
        gcloud compute addresses create IP_ADDRESS --ip-version=IPV4 --global

        Onde IP_ADDRESS é o nome do endereço IP que quer criar. O nome tem de corresponder à expressão regular (?:a-z?).

      3. Obtenha o endereço IP e guarde-o como uma variável de ambiente: 
        IP=$(gcloud compute addresses describe IP_ADDRESS --format="get(address)" --global)

        Onde IP_ADDRESS é o nome do endereço IP que criou no passo anterior.

      4. Crie um certificado TLS para nip.io, um serviço de terceiros que fornece registos DNS com carateres universais para endereços IP: 
        gcloud compute ssl-certificates create SSL_CERT_NAME \
  --domains="nip.io"

        Em que SSL_CERT_NAME é o nome do certificado que quer criar.

      Crie um grupo de pontos finais de rede (NEG)

      Para criar o grupo de pontos finais de rede (NEG) para o balanceador de carga:

      1. Crie um NEG: 
        gcloud compute network-endpoint-groups create NEG_NAME \
  --network-endpoint-type=INTERNET_FQDN_PORT \
  --default-port=443 \
  --global

        Em que NEG_NAME é o nome do NEG que quer criar.

      2. Adicione o ponto final para httpbin.org ao NEG: 
        gcloud compute network-endpoint-groups update NEG_NAME \
  --add-endpoint=fqdn=httpbin.org,port=443 \
  --global

        Onde NEG_NAME é o nome do NEG que criou no passo anterior.

      Crie um serviço de back-end

      Para criar o serviço de back-end exposto pelo balanceador de carga:

      1. Crie o serviço de back-end: 
        gcloud compute backend-services create BACKEND_SERVICE_NAME \
  --load-balancing-scheme=EXTERNAL_MANAGED \
  --protocol=HTTPS \
  --global

        Em que BACKEND_SERVICE_NAME é o nome do serviço de back-end que quer criar.

      2. Adicione o NEG ao back-end: 
        gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
  --network-endpoint-group=NEG_NAME \
  --global-network-endpoint-group \
  --global

        Onde:

        • BACKEND_SERVICE_NAME é o nome do serviço de back-end que criou no passo anterior.
        • NEG_NAME é o nome do NEG que criou num passo anterior.

      Crie um mapa de URLs

      Para criar um mapa de URLs entre o balanceador de carga e o serviço de back-end, use o seguinte comando: 

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

      Onde:

      • URL_MAP_NAME é o nome do mapa de URLs que quer criar.
      • BACKEND_SERVICE_NAME é o nome do serviço de back-end que criou num passo anterior.

      Crie um proxy de destino

      Para criar um proxy de destino para o equilibrador de carga, use o seguinte 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

      Onde:

      • TARGET_PROXY_NAME é o nome do proxy de destino que quer criar.
      • URL_MAP_NAME é o nome do mapa de URLs que criou num passo anterior.
      • SSL_CERT_NAME é o nome do certificado SSL que criou para nip.io num passo anterior.

      Crie uma regra de encaminhamento global

      Para criar uma regra de encaminhamento global para o balanceador de carga, use o seguinte 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

      Onde:

      • FORWARDING_RULE_NAME é o nome da regra de encaminhamento que quer criar.
      • IP_ADDRESS é o nome do endereço IP do ponto final do NEG que criou num passo anterior.
      • TARGET_PROXY_NAME é o nome do proxy de destino que criou num passo anterior.

      Configure o processador de extensões do Apigee

      As secções seguintes descrevem os passos necessários para configurar o Apigee Extension Processor:

      1. Crie um ambiente do Apigee.
      2. Crie o proxy do processador de extensões.

      Crie um ambiente do Apigee

      1. Crie um ambiente do Apigee com o seguinte 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"
            }
          ]
        }
    }'

        Em que ENV_NAME é o nome do ambiente que está a criar. O nome tem de conter entre 2 e 32 carateres, que podem ser letras minúsculas, números ou hífenes. O nome tem de começar com uma letra e não pode terminar com um hífen. O nome tem de ser diferente de qualquer outro nome de ambiente na sua organização.

        Confirme que o ambiente foi criado: 

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

        A lista de ambientes deve incluir o ambiente que acabou de criar.

      2. Associe o ambiente recém-criado à sua instância do 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"
        }'

        Em que ENV_NAME é o nome do ambiente que criou no passo anterior.

        Esta operação pode demorar até 10 minutos.

      3. Crie o grupo de ambientes do 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"]
        }'

        Onde:

        • ENV_GROUP_NAME é o nome do grupo de ambientes que está a criar.
        • ENV_GROUP_HOSTNAME é o nome do anfitrião do grupo de ambientes que está a criar. O nome do anfitrião tem de ser um nome de domínio totalmente qualificado (FQDN).
      4. Associe o novo ambiente ao novo grupo de ambientes: 
        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"
        }'

        Onde:

        • ENV_GROUP_NAME é o nome do grupo de ambientes que está a criar.
        • ENV_NAME é o nome do ambiente que criou num passo anterior.

      Crie o proxy do processador de extensões

      Para criar um proxy de API sem destino do Apigee para utilização com o equilibrador de carga do processador de extensões:

      1. Siga os passos em Criar um proxy de API para criar um proxy Sem destino com as seguintes especificações:
        • Modelo de proxy: selecione Nenhuma segmentação.
        • Nome do proxy: introduza um nome do proxy.
        • Caminho base: defina o caminho base que quiser. O caminho não vai ser usado.

        A especificação XML do proxy deve ser semelhante à seguinte: 

        <?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>
      2. Siga os passos em Implemente um proxy de API para implementar o proxy no ambiente que criou anteriormente.

      Configure a extensão de tráfego

      Esta secção descreve como configurar a extensão do serviço de tráfego para o processador de extensões através dos seguintes passos:

      1. Crie um grupo de pontos finais da rede do Private Service Connect do Apigee.
      2. Crie uma extensão de serviço de balanceador de carga.
      3. Envie um pedido ao balanceador de carga.

      Crie um grupo de pontos finais da rede do Private Service Connect do Apigee

      Nesta secção, vai criar um grupo de pontos finais da rede (NEG) do Private Service Connect (PSC) do Apigee que é usado para estabelecer ligação à sua instância do Apigee. Para saber mais acerca do PSC, consulte o artigo Padrões de rede de saída.

      Para criar um NEG do PSC do Apigee:

      1. Obtenha a associação do serviço do PSC do 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' \
    )

        Para ver a associação de serviço: 

        echo $PSC_ATTACHMENT

        A resposta deve ser semelhante à seguinte: 

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

      2. Crie o NEG do PSC na mesma região que a sua instância do 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

        A resposta deve ser semelhante à seguinte: 

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

      3. Crie um serviço de back-end HTTP/2 que aponte para o NEG do PSC, se ainda não existir: 
        gcloud compute backend-services create PSC_NEG_BACKEND_SERVICE \
  --load-balancing-scheme=EXTERNAL_MANAGED \
  --protocol=HTTP2 \
  --global

        Em que PSC_NEG_BACKEND_SERVICE é o nome do serviço de back-end que quer criar.

      4. Adicione o serviço de back-end do NEG do PSC: 
        gcloud compute backend-services add-backend PSC_NEG_BACKEND_SERVICE \
  --network-endpoint-group=apigee-neg-$REGION \
  --network-endpoint-group-region=$REGION \
  --global

        Em que PSC_NEG_BACKEND_SERVICE é o nome do serviço de back-end que criou num passo anterior.

      5. Ative o registo para o serviço de back-end: 
        gcloud compute backend-services update PSC_NEG_BACKEND_SERVICE \
  --global \
  --enable-logging \
  --logging-sample-rate=1.0

        Em que PSC_NEG_BACKEND_SERVICE é o nome do serviço de back-end que criou num passo anterior.

      Crie uma extensão de serviço de balanceador de carga

      Ao criar uma extensão de serviço de balanceador de carga, pode personalizar o comportamento do proxy do processador de extensões alterando os valores de vários campos que descrevem a extensão, conforme mostrado na tabela seguinte:

      Processamento corporal Eventos suportados Metadados Modo de envio
      Processamento do corpo do pedido e da resposta

      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
      Apenas processamento do corpo do pedido

      REQUEST_HEADERS

      REQUEST_BODY

      REQUEST_TRAILERS

      RESPONSE_HEADERS

      apigee-request-body: true

      requestBodySendMode: BODY_SEND_MODE_FULL_DUPLEX_STREAMED
      Apenas processamento do corpo da resposta

      REQUEST_HEADERS

      RESPONSE_HEADERS

      RESPONSE_BODY

      RESPONSE_TRAILERS

      apigee-response-body: true

      responseBodySendMode: BODY_SEND_MODE_FULL_DUPLEX_STREAMED

      Neste passo, vai criar uma extensão de serviço de balanceador de carga que suporta o processamento do corpo do pedido e da resposta: 

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

      Onde:

      • EXT_PROC_NAME Este nome tem de corresponder ao nome do proxy da API que criou num passo anterior.
      • FORWARDING_RULE_NAME é o nome da regra de encaminhamento que criou num passo anterior.
      • ENV_GROUP_HOSTNAME é o nome do domínio usado para o grupo de ambientes.
      • PSC_NEG_BACKEND_SERVICE é o nome do serviço de back-end que criou num passo anterior.

      Esta operação pode demorar alguns minutos a ser concluída.

      Para confirmar que a extensão de serviço foi criada, use o seguinte 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"

      A resposta deve ser semelhante à seguinte e apresentar a regra de encaminhamento e o serviço de back-end: 

      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'

      Envie um pedido ao balanceador de carga

      Para testar a configuração do balanceador de carga e do processador de extensões, envie um pedido para o balanceador de carga: 

      curl "https://LB_DOMAIN_NAME/get"

      Em que LB_DOMAIN_NAME é o nome do domínio que usou para o equilibrador de carga e o certificado SSL. Se tiver usado nip.io, o nome do domínio vai ser semelhante a IP_ADDRESS.nip.io.

      A resposta deve ser semelhante à seguinte: 

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

      Use políticas com o processador de extensões

      Esta secção descreve como usar políticas com o processador de extensões.

      Neste exemplo, uma política VerifyAPIkey e AssignMessage estão configuradas para o processador de extensões. Estas políticas são usadas para validar as chaves da API incluídas em pedidos ao Apigee e injetar um token nos cabeçalhos dos pedidos para chamadas a um serviço de back-end. GoogleEste cenário seria útil para fornecedores de API que usam o processador de extensões do Apigee para autorizar e autenticar pedidos aos respetivos serviços do Apigee e injetar sem problemas os Google tokens de autorização necessários para um serviço de back-end, como a Vertex AI.

      Adicione a política VerifyAPIKey para a validação da chave da API

      As secções seguintes descrevem como usar a política VerifyAPIKey para validar chaves de API para chamadas ao seu serviço de back-end através do processador de extensões:

      1. Anexe a política VerifyAPIKey ao processador de extensões.
      2. Crie um produto API.
      3. Crie uma app de programador e credenciais da app.
      4. Envie um pedido ao equilibrador de carga através da chave da API.

      Anexe a política VerifyAPIKey ao proxy

      Para anexar uma política VerifyAPIKey ao proxy Extension Processor:

      1. Na IU do Apigee na Cloud Console, aceda ao separador Desenvolver e selecione o proxy do processador de extensões que criou num passo anterior.
      2. Na secção Políticas, clique em + Adicionar política.
      3. No painel Adicionar política, selecione VerifyAPIKey na lista de políticas.
      4. No painel VerifyAPIKey, preencha os campos obrigatórios nas secções Nome da política e Nome a apresentar com os seguintes valores:
        • Nome da política: introduza um nome da política. Por exemplo, VA-verify-api-key.
        • Nome a apresentar: introduza o nome da política para utilização na IU. Por exemplo, VA-verify-api-key.
      5. Clique em Criar.

        A especificação XML da política VerifyAPIKey incluída no proxy Extension Processor deve ser semelhante à seguinte: 

          <?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>
      6. Implemente a nova revisão do proxy.

      Crie um produto de API

      Para criar um produto de API e configurar o conjunto de operações da API para o seu serviço:

      1. Siga os passos em Criar um produto de API para criar um produto de API para o seu serviço. Pode configurar os Detalhes do produto do produto da API da forma que quiser.
      2. Siga os passos em Operações para adicionar um conjunto de operações da API ao produto da API, de acordo com as seguintes especificações:
        • Origem: escolha Proxy de API e selecione o proxy que criou num passo anterior.
        • Operação: configure os seguintes caminhos e métodos:
          • Caminho: /get com o método: GET
          • Caminho: /PROXY_NAME com o método: GET

            PROXY_NAME é o nome do proxy que criou num passo anterior.

      Crie uma app de programador e credenciais da app

      Para criar uma app de programador e credenciais da app para o produto de API recém-criado:

      1. Aceda à página Gestão de APIs da Apigee na Google Cloud consola:

        Gestão de APIs da Apigee

      2. Crie um programador:
        1. Selecione Distribuição > Programadores.
        2. Na página Programadores, clique em + Criar.
        3. Na página Adicionar programador, preencha os campos obrigatórios com os valores que quiser.
        4. Clique em Adicionar.
      3. Crie uma app:
        1. Selecione Distribuição> Apps.
        2. Na página Apps, clique em + Criar
        3. Na página Criar app, preencha os campos obrigatórios na secção Detalhes da app com os seguintes valores:
          • Nome da app: introduza um nome para a app. Por exemplo, ext-proc-app
          • Programador: selecione o programador que criou no passo anterior ou outro programador da lista.
        4. Na secção Credenciais da app, clique em + Adicionar credencial.
        5. Na secção Credencial, selecione Nunca na caixa de lista Validade.
        6. Na secção Produtos, clique em + Adicionar produtos para apresentar o painel Adicionar produtos.
        7. Selecione o produto API que criou no passo anterior.
        8. Clique em OK.
        9. Clique em Adicionar para fechar o painel Adicionar produtos.
        10. Clique em Criar.
      4. Na página Detalhes da app, na secção Credencial, clique em para apresentar o valor da Chave.

        Copie o valor Key. Vai usar esta chave para fazer chamadas API ao seu serviço num passo posterior.

      5. Na página Detalhes da app, na secção Credencial, clique em para apresentar o valor do segredo da app.

      Envie um pedido ao balanceador de carga através da chave da API

      Para testar a validação da chave de API, envie um pedido para o equilibrador de carga através da chave de API: 

      curl "https://LB_DOMAIN_NAME/get"

      Em que LB_DOMAIN_NAME é o nome do domínio que usou para o equilibrador de carga e o certificado SSL.

      A resposta deve falhar sem uma chave API.

      Envie outro pedido ao equilibrador de carga, usando a chave de API no pedido: 

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

      Onde:

      • LB_DOMAIN_NAME é o nome do domínio que usou para o equilibrador de carga e o certificado SSL.
      • API_KEY é a chave da API das credenciais da app de programador reveladas num passo anterior.

      A resposta deve indicar a autorização bem-sucedida do ponto final. Isto indica que o processador de extensões validou a chave da API e que o pedido pode agora ser processado pelo proxy do Apigee.

      Adicione a política AssignMessage para a Google autenticação

      Se quiser usar o seu processador de extensões para fornecer gestão de APIs para um serviço autenticado pela Google, pode injetar um token de acesso da Google ou um token de ID da Google em pedidos enviados para o serviço de back-end através da política AssignMessage.

      As secções seguintes descrevem como usar a política AssignMessage para injetar um token de autenticação Google em pedidos enviados para o serviço de back-end através do processador de extensões:

      1. Anexe a política AssignMessage ao proxy.
      2. Envie um pedido ao balanceador de carga para testar a injeção de tokens.

      Anexe a política AssignMessage ao proxy

      Para adicionar a política AssignMessage ao proxy:

      1. Na IU do Apigee na Cloud Console, aceda ao separador Develop e selecione o proxy que criou num passo anterior.
      2. Na secção Políticas, clique em + Adicionar política.
      3. No painel Adicionar política, selecione Atribuir mensagem na lista de políticas.
      4. No painel Atribuir mensagem, preencha os campos obrigatórios nas secções Nome da política e Nome a apresentar com os seguintes valores:
        • Nome da política: introduza um nome da política. Por exemplo, AM-auth.
        • Nome a apresentar: introduza um nome da política a apresentar na IU. Por exemplo, AM-auth.
      5. Clique em Criar.
      6. No elemento <Set>, adicione os seguintes elementos subordinados: 
        <Set>
    <Authentication>
    <HeaderName>Authorization</HeaderName>
    <GoogleAccessToken>
        <Scopes>
        <Scope>https://www.googleapis.com/auth/cloud-platform</Scope>
        </Scopes>
    </GoogleAccessToken>
    </Authentication>
</Set>
      7. Clique em Guardar.
      8. Implemente a nova revisão através de uma Google conta de serviço.

      A conta de serviço é usada para gerar Google tokens de acesso e injetá-los no cabeçalho do pedido para chamadas da API para Google serviços de back-end.

      Envie um pedido ao balanceador de carga para testar a injeção de tokens

      Para confirmar que a injeção de tokens está a funcionar, envie um pedido para o equilibrador de carga: 

      curl "https://LB_DOMAIN_NAME/get"

      Em que LB_DOMAIN_NAME é o nome do domínio que usou para o equilibrador de carga e o certificado SSL.

      A resposta deve ser semelhante à seguinte: 

      {
  ...
  "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"
  },
  ...
}

      A resposta deve mostrar a injeção bem-sucedida do Google token de autenticação no cabeçalho do pedido.

      Com a aplicação bem-sucedida da política AssignMessage, o pedido bem-sucedido do cliente (que contém a chave da API) ao Apigee no cenário de exemplo é modificado ainda mais para incluir um token de autenticação Google no cabeçalho do pedido, conforme exigido pelo serviço de back-end autenticado com Google.