Provisionar uma organização de avaliação sem peering de VPC

Esta página se aplica à Apigee, mas não à Apigee híbrida.

Confira a documentação da Apigee Edge.

Neste documento, explicamos como instalar e configurar uma organização de avaliação da Apigee a partir da linha de comando sem peering de VPC. As organizações de avaliação expiram após 60 dias e podem ter outras limitações. Consulte também Como comparar organizações pagas e de avaliação.

Limitações

A opção de instalação de peering sem VPC descrita neste documento tem algumas limitações:

VPC Service Controls não são compatíveis.
O peering de DNS particular não é compatível.

Para uma lista completa de recursos e abordagens de rede compatíveis e não compatíveis com peering sem VPC, consulte Como escolher uma opção de rede.

Resumo das etapas

As etapas de provisionamento são as seguintes:

Etapa 1: definir as variáveis de ambiente: configure o gcloud e defina as variáveis de ambiente. A Google Cloud CLI gerencia a autenticação, a configuração local, o fluxo de trabalho do desenvolvedor e as interações com as APIs do Google Cloud.
Etapa 2: ativar APIs: a Apigee requer a ativação de várias APIs do Google Cloud.
Etapa 3: criar uma organização: uma organização da Apigee (às vezes chamada de organização) é o contêiner de nível superior da Apigee. Ela inclui todos os ambientes e grupos de ambientes, usuários, proxies de API e recursos relacionados.
Etapa 4: configurar o roteamento: permita o acesso externo ou apenas acesso interno à API.
Etapa 5: chamar o proxy de API de amostra: teste o provisionamento implantando e chamando um proxy de API.

Etapa 1: definir variáveis de ambiente

Configure gcloud e defina variáveis de ambiente para uso em etapas posteriores:

Verifique se você atende aos requisitos de configuração listados em Pré-requisitos.
A CLI gcloud precisa estar instalada. Se precisar instalá-lo, consulte Como instalar a CLI gcloud.
Inicialize a CLI gcloud, conforme descrito em Como inicializar a CLI gcloud, ou, se a CLI já estiver inicializada, verifique se o projeto do Google Cloud que você criou em Pré-requisitos é o projeto padrão para o gcloud.
Defina as seguintes variáveis de ambiente:
```
AUTH="Authorization: Bearer $(gcloud auth print-access-token)"
PROJECT_ID="YOUR_PROJECT_ID"
RUNTIME_LOCATION="YOUR_RUNTIME_LOCATION"
ANALYTICS_REGION="YOUR_ANALYTICS_REGION"
```
Em que:
- AUTH define o cabeçalho Authentication com um token do portador. Você usará esse cabeçalho ao chamar as APIs da Apigee. Observe que o token expira após um certo tempo. Quando isso acontecer, basta gerar o token novamente usando o mesmo comando. Saiba mais na página de referência do comando print-access-token.
- PROJECT_ID é o ID do projeto do Cloud que você criou como parte dos pré-requisitos.
- RUNTIME_LOCATION é o local físico em que a instância da Apigee está localizada. Para conferir uma lista de locais disponíveis para o ambiente de execução, consulte Locais da Apigee.
  
  Observação: para RUNTIME_LOCATION, use um nome de região, não de uma zona. Por exemplo, us-west1 é um nome de região, enquanto us-west1-a é uma zona na região. Consulte também Como identificar uma região ou uma zona.
- ANALYTICS_REGION é o local físico em que os dados de análise da Apigee são armazenados. Para conferir uma lista de regiões disponíveis do Apigee API Analytics, consulte os locais da Apigee.
  
  RUNTIME_LOCATION e RUNTIME_LOCATION podem ser a mesma região, mas não precisam ser os mesmos. No entanto, isso poderá resultar em uma melhoria no desempenho.

(Opcional) Verifique seu trabalho incluindo os valores que você acabou de definir. Quando quiser usar uma variável nos comandos, coloque o cifrão ($) antes do nome dela.

echo $AUTH
echo $PROJECT_ID
echo $RUNTIME_LOCATION
echo $ANALYTICS_REGION

As respostas aos comandos echo precisam ser semelhantes a estas:

Authorization: Bearer ya29.a123456678940B63hPSAMPLEsampleKKYVsample0f3pWDWZDuH2-hENkNa
TvgZ1PD977TMvv6edBQPJezdHw040880Ol_LoD5ZDkt-i-knizia_KhA9L20sSvztL81-SAMPLE42ELPMASk2_
1CxN
my-cloud-project
us-west1
us-west1

Etapa 2: ativar as APIs

Permissões exigidas para a tarefa

É possível conceder ao provisionador da Apigee um papel predefinido que inclui as permissões necessárias para concluir essa tarefa ou conceder permissões mais refinadas para fornecer o privilégio mínimo necessário. Consulte Papéis predefinidos e Permissões de ativação de API.

A Apigee requer a ativação de várias APIs do Google Cloud. Ative as APIs executando o seguinte comando services enable:
```
gcloud services enable apigee.googleapis.com \
  cloudkms.googleapis.com --project=$PROJECT_ID
```
(Opcional) Para verificar seu trabalho, use o comando services list para mostrar todas as APIs ativadas:
```
gcloud services list
```
A resposta mostra todos os serviços ativados, incluindo as APIs que você acabou de ativar (Apigee, Cloud KMS e Compute Engine).

Etapa 3: criar uma organização

Uma organização é o contêiner de nível superior no Apigee. Ela contém todos os proxies de API e recursos relacionados. Saiba mais em Noções básicas sobre organizações.

Permissões exigidas para a tarefa

Crie uma nova organização de avaliação com a API provisionOrganization:
Observação: a API provisionOrganization só pode criar organizações de avaliação. Ele não pode ser usado para criar organizações de produção.
```
 suppresswarning="true">curl "https://apigee.googleapis.com/v1/projects/$PROJECT_ID:provisionOrganization"  \
  -H "$AUTH" \
  -X POST \
  -H "Content-Type:application/json" \
  -d '{
    "analyticsRegion":"'"$ANALYTICS_REGION"'",
    "runtimeLocation":"'"$RUNTIME_LOCATION"'",
    "disableVpcPeering":"true",
  }'
```
Em que:
- -d define o payload de dados para a solicitação. Esse payload precisa incluir o seguinte:
  - ANALYTICS_REGION: especifica o local físico em que os dados de análise serão armazenados.
  - RUNTIME_LOCATION: é o local físico em que a instância da Apigee está localizada.
  - disableVpcPeering: neste fluxo de provisionamento, não estamos usando peering de VPC. Portanto, essa sinalização precisa ser definida como true. Padrão: false
A Apigee inicia uma LRO para criar a organização de avaliação. Essa operação leva até 40 minutos para ser concluída.
Para verificar o status da solicitação de criação, envie uma solicitação GET para a API List organizations da Apigee, como no exemplo abaixo:
```
curl -H "$AUTH" "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID"
```
Se você vir essa resposta, a criação da organização ainda não foi concluída:
```
{
"error": {
"code": 403,
"message": "Permission denied on resource \"organizations/apigee-docs-m\" (or it may not exist)",
"status": "PERMISSION_DENIED"
}
}
```
Se for bem-sucedido, o objeto de resposta indicará "state": "ACTIVE", e você poderá avançar para a próxima etapa.

Etapa 4: configurar o roteamento

Nesta etapa, você vai configurar a comunicação dos aplicativos clientes com a Apigee. O tráfego do cliente para a Apigee também é chamado de tráfego "norte". As opções de configuração na direção norte incluem:

Tipo de acesso	Descrição do processo de configuração e implantação
Interno com o PSC	Permita apenas o acesso interno aos proxies da API de qualquer um dos seus projetos do Google Cloud usando o Private Service Connect (PSC). O PSC permite uma conexão particular entre um produtor de serviços (Apigee) e um consumidor de serviço (o projeto VPC com peering e/ou um ou mais projetos do Cloud que você controla). Com esse método, as solicitações passam por um endpoint de serviço ou um balanceador de carga regional interno para um único ponto de anexo, chamado de anexo de serviço. Essa configuração permite que os clientes internos enviem solicitações de proxy da API da Apigee de qualquer máquina ativada para rede.
Externo com o PSC	Permite o acesso externo aos proxies de API usando o Private Service Connect (PSC). Use o Private Service Connect (PSC) para ativar a conexão particular entre um produtor de serviços (Apigee) e um consumidor de serviço (o projeto VPC com peering e/ou um ou mais projetos do Cloud que você controla). Com esse método, as solicitações são transmitidas por um balanceador de carga externo global ou regional para um único ponto de anexo, chamado anexo de serviço. Essa configuração permite enviar solicitações de proxy de API da Apigee de qualquer máquina ativada para rede.

Tipo de acesso

Descrição do processo de configuração e implantação

Interno com o PSC

Permita apenas o acesso interno aos proxies da API de qualquer um dos seus projetos do Google Cloud usando o Private Service Connect (PSC).

O PSC permite uma conexão particular entre um produtor de serviços (Apigee) e um consumidor de serviço (o projeto VPC com peering e/ou um ou mais projetos do Cloud que você controla). Com esse método, as solicitações passam por um endpoint de serviço ou um balanceador de carga regional interno para um único ponto de anexo, chamado de anexo de serviço. Essa configuração permite que os clientes internos enviem solicitações de proxy da API da Apigee de qualquer máquina ativada para rede.

Externo com o PSC

Permite o acesso externo aos proxies de API usando o Private Service Connect (PSC).

Use o Private Service Connect (PSC) para ativar a conexão particular entre um produtor de serviços (Apigee) e um consumidor de serviço (o projeto VPC com peering e/ou um ou mais projetos do Cloud que você controla). Com esse método, as solicitações são transmitidas por um balanceador de carga externo global ou regional para um único ponto de anexo, chamado anexo de serviço. Essa configuração permite enviar solicitações de proxy de API da Apigee de qualquer máquina ativada para rede.

Cada uma destas abordagens de roteamento é apresentada em uma guia nas instruções abaixo.

Roteamento interno (PSC, na sigla em inglês)

Nesta seção, explicamos como permitir apenas o acesso interno aos proxies de API de qualquer projeto do Google Cloud usando o Private Service Connect (PSC).

Você tem duas opções para configurar o acesso interno com o PSC:

Endpoint de serviço: as solicitações são transmitidas por um endpoint de serviço para um único ponto de anexo, chamado anexo de serviço.
Balanceador de carga regional interno: as solicitações passam por um balanceador de carga HTTP(S) regional interno. Consulte também Balanceamento de carga global vs. regional.

Selecione a guia abaixo para a configuração que você escolheu e siga as etapas:

Endpoint de serviço

Permissões exigidas para a tarefa

Criação de um endpoint de serviço do PSC para o anexo de serviço

Consiga o anexo do serviço da instância da Apigee:

curl -i -X GET -H "$AUTH" \
  "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances"

No exemplo de saída a seguir, o valor serviceAttachment é mostrado em negrito:

{
  "instances": [
    {
      "name": "us-west1",
      "location": "us-west1",
      "createdAt": "1645731488019",
      "lastModifiedAt": "1646504754219",
      "diskEncryptionKeyName": "projects/my-project/locations/us-west1/keyRings/us-west1/cryptoKeys/dek",
      "state": "ACTIVE",
      "runtimeVersion": "1-7-0-20220228-190814",
      "consumerAcceptList": [
        "my-project"
      ],
      "serviceAttachment": "projects/bfac74a67a320c43a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw1"
    }
  ]
}

Observação: o ID do projeto que você usou para criar a organização da Apigee sempre aparece na lista consumerAcceptList. No exemplo de saída mostrado acima, ele é o único projeto da lista.

Crie um endpoint de serviço do PSC que aponte para o anexo de serviço que você recebeu do corpo de resposta da instância na etapa anterior, conforme explicado em Criar um endpoint do Private Service Connect.
Lembre-se do endereço IP do endpoint do serviço. Você precisará do endereço IP posteriormente ao testar a configuração chamando um proxy de API. Por exemplo: 10.138.0.2.

O provisionamento da Apigee foi concluído. Acesse Implantar um proxy de amostra.

Balanceador de carga interno regional

Permissões exigidas para a tarefa

Restrições: lembre-se das seguintes restrições para a configuração do PSC:

O balanceador de carga HTTP(S) externo global (clássico) não é compatível com essa configuração.
Para failover com vários NEGs da PSC, verificações de integridade ativas não são compatíveis. Use a detecção de outlier.
Os limites se aplicam ao número de projetos do Google Cloud que podem se conectar a uma instância da Apigee pela PSC e ao número de conexões NEG da PSC que você pode ter por projeto. Para mais detalhes, consulte Limites do Private Service Connect (PSC).
Se um projeto do Google Cloud for removido de consumerAcceptList, os NEGs de PSC existentes nesse projeto removido continuarão funcionando. No entanto, os novos NEGs serão recusados. Você precisará excluir os NEGs atuais se remover os projetos associados a eles do consumerAcceptList. Também é possível recriar a instância da Apigee, que recria o anexo de serviço no projeto da Apigee.

Etapa 8a: configurar as variáveis de ambiente

Nas instruções desta seção, usamos variáveis de ambiente para fazer referência às strings usadas várias vezes. Verifique se você definiu as variáveis em Definir variáveis de ambiente.

Além disso, defina as variáveis de ambiente a seguir:

Defina as variáveis de ambiente a seguir no terminal de comando:

NEG_NAME=YOUR_NEG_NAME"
TARGET_SERVICE=YOUR_TARGET_SERVICE"
NETWORK_NAME=YOUR_NETWORK_NAME"
SUBNET_NAME=YOUR_SUBNET_NAME"

Em que:

NEG_NAME: um nome para o grupo de endpoints da rede.
TARGET_SERVICE: o anexo de serviço ao qual você quer se conectar. Por exemplo: projects/bfac7497a40c32a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw7
NETWORK_NAME: (opcional) nome da rede em que o NEG foi criado. Se você omitir esse parâmetro, a rede do projeto default será usada.
SUBNET_NAME: nome da sub-rede usada para conectividade particular com o produtor. O tamanho da sub-rede pode ser pequeno: o NEC PSC só precisa de um IP da sub-rede. Para a Apigee, apenas um NEG de PSC é necessário por região. A sub-rede pode ser compartilhada e usada por VMs ou outras entidades. Se uma sub-rede não for especificada, os endpoints de rede poderão pertencer a qualquer sub-rede da região em que o grupo de endpoints de rede for criado.
OBSERVAÇÃO: se você especificar o parâmetro --network, especifique também --subnet.

Etapa 8b: criar uma sub-rede somente proxy

gcloud compute networks subnets create testproxyonlysubnet \
  --purpose=REGIONAL_MANAGED_PROXY --role=ACTIVE --region=$RUNTIME_REGION --network=$NETWORK_NAME \
  --range=100.0.0.0/24 --project=$PROJECT_ID

Etapa 8c: criar um grupo de endpoints de rede (NEG)

Consiga o anexo de serviço da instância criada anteriormente:

curl -i -X GET -H "$AUTH" \
"https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances"

No exemplo de saída a seguir, o valor serviceAttachment é mostrado em negrito:

{
"instances": [
  {
    "name": "us-west1",
    "location": "us-west1",
    "createdAt": "1645731488019",
    "lastModifiedAt": "1646504754219",
    "diskEncryptionKeyName": "projects/my-project/locations/us-west1/keyRings/us-west1/cryptoKeys/dek",
    "state": "ACTIVE",
    "runtimeVersion": "1-7-0-20220228-190814",
    "consumerAcceptList": [
      "my-project"
    ],
    "serviceAttachment": "projects/bfac7497a40c32a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw7"
  }
]
}

Crie um NEG do Private Service Connect que aponte para o anexo de serviço recebido do corpo de resposta da instância na etapa anterior.

gcloud compute network-endpoint-groups create $NEG_NAME \
--network-endpoint-type=private-service-connect \
--psc-target-service=$TARGET_SERVICE \
--region=$RUNTIME_LOCATION \
--project=$PROJECT_ID

Etapa 8d: configurar o balanceador de carga interno regional

Reserve um endereço IPv4 interno para o balanceador de carga.

gcloud compute addresses create ADDRESS_NAME \
--ip-version=IPV4 --subnet=$SUBNET_NAME \
  --region=$RUNTIME_LOCATION --project=$PROJECT_ID

Substitua ADDRESS_NAME por um nome para o recurso de endereço IP.

Execute este comando para ver o endereço IP reservado:

gcloud compute addresses describe ADDRESS_NAME \
--format="get(address)" --region=RUNTIME_LOCATION --project=$PROJECT_ID

Crie um serviço de back-end para o NEG:

gcloud compute backend-services create BACKEND_SERVICE_NAME \
--load-balancing-scheme=INTERNAL_MANAGED \
--protocol=HTTPS \
--region=$RUNTIME_REGION \
--project=$PROJECT_ID

Substitua BACKEND_SERVICE_NAME pelo nome do serviço de back-end.

Adicione o NEG ao serviço de back-end.

gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
--network-endpoint-group=NEG_NAME \
--region=$RUNTIME_LOCATION \
--project=$PROJECT_ID

Substitua:

BACKEND_SERVICE_NAME: o nome do serviço de back-end.
NEG_NAME: o nome do grupo de endpoints da rede.

Você precisa ter um recurso de certificado SSL para usar no proxy de destino HTTPS.

Use este comando para criar um recurso de certificado SSL autogerenciado. Para criar um certificado SSL autogerenciado, você precisa de um arquivo de chave privada local e de um arquivo de certificado local. Se você precisar criar esses arquivos, consulte a etapa 1 de usar certificados SSL autogerenciados.

Observação: os certificados gerenciados pelo Google não são compatíveis com o balanceador de carga regional interno.
```
gcloud compute ssl-certificates create CERTIFICATE \
--certificate LB_CERT \
--private-key LB_PRIVATE_KEY
--region=RUNTIME_LOCATION --project=$PROJECT_ID
```
Substitua:
- CERTIFICATE: um nome para o certificado.
- LB_CERT: o caminho para o arquivo de certificado formatado em PEM do certificado autogerenciado.
- LB_PRIVATE_KEY: o caminho para o arquivo de chave privada formatado em PEM do certificado autogerenciado.
Crie um mapa de URL para o balanceador de carga.

Um mapa de URL precisa referir-se a um serviço de back-end padrão. Defina o serviço de back-end que você acabou de criar como padrão.
```
gcloud compute url-maps create URL_MAP_NAME \
    --default-service=DEFAULT_BACKEND_SERVICE_NAME \
    --global --project=$PROJECT_ID
```
Substitua:
- URL_MAP_NAME: um nome para o mapa de URL.
- DEFAULT_BACKEND_SERVICE_NAME: o nome do serviço de back-end padrão do balanceador de carga. O padrão é usado quando nenhuma regra de host corresponde ao nome do host solicitado.
Use o recurso de certificado SSL para criar um proxy de destino HTTPS.
```
gcloud compute target-https-proxies create PROXY_NAME \
--url-map=URL_MAP_NAME \
--ssl-certificates=CERTIFICATE \
--region=$RUNTIME_LOCATION --project=$PROJECT_ID
```
Substitua:
- PROXY_NAME: um nome para o proxy HTTPS de destino.
- URL_MAP_NAME: o nome do mapa de URL.
- CERTIFICATE: o nome do recurso de certificado.

Crie a regra de encaminhamento.

gcloud compute forwarding-rules create FWD_RULE \
--load-balancing-scheme=INTERNAL_MANAGED \
--address=ADDRESS_NAME \
--target-https-proxy=PROXY_NAME \
--ports=443 \
--target-https-proxy-region=$RUNTIME_REGION \
--region=$RUNTIME_REGION
--project=$PROJECT_ID

Substitua:

FWD_RULE: um nome para a regra de encaminhamento.
ADDRESS_NAME: o recurso de endereço IP que você reservou para usar na regra de encaminhamento.
PROXY_NAME: o nome do proxy HTTPS de destino.

O provisionamento da Apigee foi concluído. Acesse Implantar um proxy de amostra.

Roteamento externo (PSC)

Nesta seção, descrevemos como configurar o roteamento externo usando o Private Service Connect (PSC, na sigla em inglês) para permitir a comunicação entre a Apigee e as VPCs que você controla. É necessário fazer isso para enviar uma solicitação de um cliente externo à instância de ambiente de execução da Apigee.

Permissões exigidas para a tarefa

Restrições: lembre-se das seguintes restrições para a configuração do PSC:

O balanceador de carga HTTP(S) externo global (clássico) não é compatível com essa configuração.
Para failover com vários NEGs da PSC, verificações de integridade ativas não são compatíveis. Use a detecção de outlier.
Os limites se aplicam ao número de projetos do Google Cloud que podem se conectar a uma instância da Apigee pela PSC e ao número de conexões NEG da PSC que você pode ter por projeto. Para mais detalhes, consulte Limites do Private Service Connect (PSC).
Se um projeto do Google Cloud for removido de consumerAcceptList, os NEGs de PSC existentes nesse projeto removido continuarão funcionando. No entanto, os novos NEGs serão recusados. Você precisará excluir os NEGs atuais se remover os projetos associados a eles do consumerAcceptList. Também é possível recriar a instância da Apigee, que recria o anexo de serviço no projeto da Apigee.

Etapa 8b: criar um NEG e configurar o balanceador de carga

É possível criar um balanceador de carga regional ou global.

Balanceador de carga externo global

Configure um balanceador de carga HTTP(S) externo global (esquema de balanceamento de carga definido como EXTERNAL_MANAGED).

Embora o NEG do Private Service Connect seja regional, todos os outros componentes de balanceamento de carga nessa configuração são globais.

Verifique se você definiu as variáveis de ambiente neste link.

Consiga o anexo de serviço da instância criada anteriormente:

curl -i -X GET -H "$AUTH" \
      "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances"

No exemplo de saída a seguir, o valor serviceAttachment é mostrado em negrito:

{
      "instances": [
        {
          "name": "us-west1",
          "location": "us-west1",
          "host": "10.82.192.2",
          "port": "443",
          "createdAt": "1645731488019",
          "lastModifiedAt": "1646504754219",
          "diskEncryptionKeyName": "projects/my-project/locations/us-west1/keyRings/us-west1/cryptoKeys/dek",
          "state": "ACTIVE",
          "peeringCidrRange": "SLASH_22",
          "runtimeVersion": "1-7-0-20220228-190814",
          "ipRange": "10.82.192.0/22,10.82.196.0/28",
          "consumerAcceptList": [
            "875609189304"
          ],
          "serviceAttachment": "projects/bfac7497a40c32a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw7"
        }
      ]
    }

Crie um NEG do Private Service Connect que aponte para o anexo de serviço recebido do corpo de resposta da instância na etapa anterior.
```
    gcloud compute network-endpoint-groups create $NEG_NAME \
      --network-endpoint-type=private-service-connect \
      --psc-target-service=$TARGET_SERVICE \
      --region=$RUNTIME_LOCATION \
      --network=NETWORK_NAME \
      --subnet=SUBNET_NAME \
      --project=$PROJECT_ID
    
```
Substitua:
- NETWORK_NAME: (opcional) nome da rede em que o NEG foi criado. Se você omitir esse parâmetro, a rede do projeto default será usada.
- SUBNET_NAME: nome da sub-rede usada para conectividade particular com o produtor. O tamanho da sub-rede pode ser pequeno: o NEC PSC só precisa de um IP da sub-rede. Para a Apigee, apenas um NEG de PSC é necessário por região. A sub-rede pode ser compartilhada e usada por VMs ou outras entidades. Se uma sub-rede não for especificada, os endpoints de rede poderão pertencer a qualquer sub-rede da região em que o grupo de endpoints de rede for criado.
  OBSERVAÇÃO: se você especificar o parâmetro --network, especifique também --subnet.
- PROJECT_ID O projeto do Cloud que já está associado à organização da Apigee ou um projeto do Cloud incluído no consumerAcceptlist quando a instância de ambiente de execução da Apigee foi criada.

Reserve um endereço IPv4 externo global para o balanceador de carga.

gcloud compute addresses create ADDRESS_NAME \
  --ip-version=IPV4 --global --project=$PROJECT_ID

Substitua ADDRESS_NAME por um nome para o recurso de endereço IP.

Execute este comando para ver o endereço IP reservado:

gcloud compute addresses describe ADDRESS_NAME \
  --format="get(address)" --global --project=$PROJECT_ID

Crie um serviço de back-end para o NEG:

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

Substitua BACKEND_SERVICE_NAME pelo nome do serviço de back-end.

Adicione o serviço de back-end ao NEG.

gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
  --network-endpoint-group=NEG_NAME \
  --network-endpoint-group-region=$REGION \
  --global --project=$PROJECT_ID

Substitua:

BACKEND_SERVICE_NAME: o nome do serviço de back-end.
NEG_NAME: o nome do grupo de endpoints da rede.
REGION: o nome do grupo de endpoints da rede.

Crie um mapa de URL para o balanceador de carga.

Um mapa de URL precisa referir-se a um serviço de back-end padrão. Defina o serviço de back-end que você acabou de criar como padrão.
```
gcloud compute url-maps create URL_MAP_NAME \
  --default-service=DEFAULT_BACKEND_SERVICE_NAME \
  --global --project=$PROJECT_ID
```
Substitua:
- URL_MAP_NAME: um nome para o mapa de URL.
- DEFAULT_BACKEND_SERVICE_NAME: o nome do serviço de back-end padrão do balanceador de carga. O padrão é usado quando nenhuma regra de host corresponde ao nome do host solicitado.
Crie o proxy de destino HTTPS.

Você precisa ter um recurso de certificado SSL para usar no proxy de destino HTTPS. É possível criar um recurso de certificado SSL usando um certificado SSL gerenciado pelo Google ou um certificado SSL autogerenciado. O uso de certificados gerenciados pelo Google é recomendado porque o Google Cloud recebe, gerencia e renova esses certificados automaticamente.

Para criar um certificado gerenciado pelo Google, você precisa ter um domínio.

Use este comando para criar um recurso de certificado SSL gerenciado pelo Google:
```
gcloud compute ssl-certificates create CERTIFICATE \
  --domains DOMAIN --project=$PROJECT_ID
```
Substitua:
- CERTIFICATE: um nome para o certificado.
- DOMAIN: o nome de domínio do balanceador de carga.
Use este comando para criar um recurso de certificado SSL autogerenciado. Para criar um certificado SSL autogerenciado, você precisa de um arquivo de chave privada local e de um arquivo de certificado local. Se você precisar criar esses arquivos, consulte a etapa 1 de usar certificados SSL autogerenciados.
```
gcloud compute ssl-certificates create CERTIFICATE \
  --certificate LB_CERT \
  --private-key LB_PRIVATE_KEY --project=$PROJECT_ID
```
Substitua:
- CERTIFICATE: um nome para o certificado.
- LB_CERT: o caminho para o arquivo de certificado formatado em PEM do certificado autogerenciado.
- LB_PRIVATE_KEY: o caminho para o arquivo de chave privada formatado em PEM do certificado autogerenciado.
Use o recurso de certificado SSL para criar um proxy de destino HTTPS.
```
gcloud compute target-https-proxies create PROXY_NAME \
  --url-map=URL_MAP_NAME \
  --ssl-certificates=CERTIFICATE --project=$PROJECT_ID
```
Substitua:
- PROXY_NAME: um nome para o proxy HTTPS de destino.
- URL_MAP_NAME: o nome do mapa de URL.
- CERTIFICATE: o nome do recurso de certificado.

Crie a regra de encaminhamento.

gcloud compute forwarding-rules create FWD_RULE \
  --load-balancing-scheme=EXTERNAL_MANAGED \
  --network-tier=PREMIUM \
  --address=ADDRESS_NAME \
  --target-https-proxy=PROXY_NAME \
  --ports=443 \
  --global --project=$PROJECT_ID

Substitua:

FWD_RULE: um nome para a regra de encaminhamento.
ADDRESS_NAME: o recurso de endereço IP que você reservou para usar na regra de encaminhamento.
PROXY_NAME: o nome do proxy HTTPS de destino.

O provisionamento da Apigee foi concluído. Acesse Implantar um proxy de amostra.

Balanceador de carga externo regional

Configure um balanceador de carga HTTP(S) externo regional. Consulte também Aspectos gerais do balanceador de carga HTTP(S) externo.

Verifique se você definiu as variáveis em Definir variáveis de ambiente.
Crie uma sub-rede somente proxy:
Observação: essa é uma operação única. Essa sub-rede somente proxy é necessária apenas uma vez a cada projeto do Google Cloud com qualquer balanceador de carga regional baseado no Envoy. Consulte também Sub-redes somente proxy para balanceadores de carga baseados no Envoy.
```
gcloud compute networks subnets create SUBNET_NAME \
  --purpose=REGIONAL_MANAGED_PROXY --role=ACTIVE \
  --region=$RUNTIME_LOCATION --network=NETWORK_NAME \
  --range=100.0.0.0/24 --project=$PROJECT_ID
```
- Substitua SUBNET_NAME pelo nome da subnet.
- (Opcional) Substitua o nome da rede NETWORK_NAME em que a sub-rede é criada. Se você omitir esse parâmetro, a rede do projeto padrão será usada.

Consiga o anexo de serviço da instância criada anteriormente:

curl -i -X GET -H "$AUTH" \
        "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances"

No exemplo de saída a seguir, o valor serviceAttachment é mostrado em negrito:

{
        "instances": [
          {
            "name": "us-west1",
            "location": "us-west1",
            "host": "10.82.192.2",
            "port": "443",
            "createdAt": "1645731488019",
            "lastModifiedAt": "1646504754219",
            "diskEncryptionKeyName": "projects/my-project/locations/us-west1/keyRings/us-west1/cryptoKeys/dek",
            "state": "ACTIVE",
            "peeringCidrRange": "SLASH_22",
            "runtimeVersion": "1-7-0-20220228-190814",
            "ipRange": "10.82.192.0/22,10.82.196.0/28",
            "consumerAcceptList": [
              "875609189304"
            ],
            "serviceAttachment": "projects/bfac7497a40c32a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw7"
          }
        ]
      }

Crie um grupo de endpoints da rede
```
gcloud compute network-endpoint-groups create NEG_NAME \
        --network-endpoint-type=private-service-connect \
        --psc-target-service=TARGET_SERVICE \
        --region=$RUNTIME_LOCATION --project=$PROJECT_ID
```
Substitua:
- NEG_NAME: o nome do grupo de endpoints da rede.
- TARGET_SERVICE: o nome do anexo de serviço com que você quer se conectar. Por exemplo: projects/bfac7497a40c32a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw7

Crie um serviço de back-end para o NEG:

gcloud compute backend-services create BACKEND_SERVICE_NAME \
  --load-balancing-scheme=EXTERNAL_MANAGED \
  --protocol=HTTPS \
  --region=$RUNTIME_LOCATION  \
  --project=$PROJECT_ID

Substitua BACKEND_SERVICE_NAME pelo nome do serviço de back-end.

Adicione o serviço de back-end ao NEG.

gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
  --network-endpoint-group=NEG_NAME \
  --region=$RUNTIME_LOCATION  \
  --project=$PROJECT_ID

Substitua:

BACKEND_SERVICE_NAME: o nome do serviço de back-end.
NEG_NAME: o nome do grupo de endpoints da rede.

Crie um mapa de URL para o balanceador de carga.

Um mapa de URL precisa referir-se a um serviço de back-end padrão. Defina o serviço de back-end que você acabou de criar como padrão.
```
gcloud compute url-maps create URL_MAP_NAME \
  --default-service=DEFAULT_BACKEND_SERVICE_NAME \
  --region=$RUNTIME_LOCATION  \
  --project=$PROJECT_ID
```
Substitua:
- URL_MAP_NAME: um nome para o mapa de URL.
- DEFAULT_BACKEND_SERVICE_NAME: o nome do serviço de back-end padrão do balanceador de carga. O padrão é usado quando nenhuma regra de host corresponde ao nome do host solicitado.
Crie o proxy de destino HTTPS.

Você precisa ter um recurso de certificado SSL para usar no proxy de destino HTTPS.

Use este comando para criar um recurso de certificado SSL autogerenciado. Para criar um certificado SSL autogerenciado, você precisa de um arquivo de chave privada local e de um arquivo de certificado local. Se você precisar criar esses arquivos, consulte a etapa 1 de usar certificados SSL autogerenciados.

Observação: os certificados gerenciados pelo Google não são compatíveis com o balanceador de carga regional externo.
```
gcloud compute ssl-certificates create CERTIFICATE \
  --certificate LB_CERT \
  --private-key LB_PRIVATE_KEY --region=$RUNTIME_LOCATION \
  --project=$PROJECT_ID
```
Substitua:
- CERTIFICATE: um nome para o certificado.
- LB_CERT: o caminho para o arquivo de certificado formatado em PEM do certificado autogerenciado.
- LB_PRIVATE_KEY: o caminho para o arquivo de chave privada formatado em PEM do certificado autogerenciado.

Adicione o domínio ao grupo de ambientes da Apigee que foi criado para você. O nome do grupo de ambiente é eval-group:

curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups/eval-group" \
      -H "$AUTH" \
      -X PATCH \
      -H "Content-Type:application/json" \
      -d '{
        "hostnames":["'"DOMAIN"'"]
      }'

Verifique o status da operação do grupo de ambiente:

curl -H "$AUTH" \
      "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups/eval-group/attachments"

Use o recurso de certificado SSL para criar um proxy de destino HTTPS.
```
gcloud compute target-https-proxies create PROXY_NAME \
  --url-map=URL_MAP_NAME --region=$RUNTIME_LOCATION \
  --ssl-certificates=CERTIFICATE --project=$PROJECT_ID
```
Substitua:
- PROXY_NAME: um nome para o proxy HTTPS de destino.
- URL_MAP_NAME: o nome do mapa de URL.
- CERTIFICATE: o nome do recurso de certificado.

Reserve um endereço IP externo regional para o balanceador de carga. Lembre-se que o nível da rede precisa estar definido como STANDARD.

gcloud compute addresses create ADDRESS_NAME \
      --region=$RUNTIME_LOCATION --network-tier=STANDARD \
      --project=$PROJECT_ID

Substitua ADDRESS_NAME por um nome para o recurso de endereço IP.

Execute este comando para ver o endereço IP reservado:

gcloud compute addresses describe ADDRESS_NAME \
      --format="get(address)" --region=$RUNTIME_LOCATION \
      --project=$PROJECT_ID

Crie a regra de encaminhamento.

gcloud compute forwarding-rules create FWD_RULE \
  --load-balancing-scheme=EXTERNAL_MANAGED \
  --network-tier=STANDARD \
  --address=ADDRESS_NAME \
  --target-https-proxy=PROXY_NAME \
  --ports=443  --region=$RUNTIME_LOCATION \
  --target-https-proxy-region=$RUNTIME_LOCATION --project=$PROJECT_ID

Substitua:

FWD_RULE: um nome para a regra de encaminhamento.
ADDRESS_NAME: o recurso de endereço IP que você reservou para usar na regra de encaminhamento.
PROXY_NAME: o nome do proxy HTTPS de destino.

O provisionamento da Apigee foi concluído. Acesse Chamar o proxy de API de amostra.

Etapa 5: chamar o proxy de API de amostra

Um proxy de API chamado hello-world foi criado e implantado para você durante o provisionamento. Nesta etapa, você testa a nova organização de avaliação chamando o proxy.

Permissões exigidas para a tarefa

A criação e a implantação de proxies precisam de um conjunto mínimo de permissões. Se você tiver o papel de administrador da organização da Apigee, conclua esta tarefa. Para saber mais sobre outros papéis que você pode implantar, consulte Papéis da Apigee.

Chamar o proxy de API com roteamento interno

Se você escolher um roteamento interno com uma opção de endpoint do serviço na etapa 5, siga as etapas em Como chamar um proxy de API com acesso somente interno acesso.

Chamar o proxy de API com roteamento externo

Se você escolheu a opção de roteamento externo na Etapa 5, siga as etapas nesta seção.

Configure uma entrada DNS para o host. Veja duas maneiras de realizar essa tarefa:
- No registrador, crie um registro A que aponte para seu domínio. Por exemplo, se o nome do host for sales.example.com e o IP for 10.23.0.2, aponte o registro de sales.example.com para o endereço 10.23.0.2.
  Execute este comando para ver o endereço IP reservado:
```
gcloud compute addresses describe ADDRESS_NAME \
    --format="get(address)" --region=$RUNTIME_LOCATION \
    --project=$PROJECT_ID
```
- Use o Google Cloud DNS para mapear um URL para um endereço IP.

Confirme se o proxy hello-world está implantado:

curl -i -H "$AUTH" \
  "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments/eval/apis/hello-world/revisions/1/deployments"

Chame o proxy de API:
Envie uma solicitação ao proxy de API de qualquer máquina em rede executando o seguinte comando:
```
curl -i -H "Host: DOMAIN" \
  https://DOMAIN/hello-world
```
Em que DOMAIN é o domínio que você colocou no certificado e adicionado ao grupo de ambiente, conforme discutido na Etapa 5: configurar o roteamento. Se necessário, use essa API para receber o valor DOMAIN do grupo de ambiente:
```
curl -i -H "$AUTH" \
  "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups"
```
Após a conclusão, o proxy de API de amostra retornará a resposta:
```
Hello, Guest!
```
Dicas para solução de problemas:

Se você receber um erro de handshake, verifique o status do certificado SSL. Para informações sobre como solucionar problemas de certificados autogerenciados e gerenciados pelo Google, consulte Solução de problemas de certificados SSL.
Verifique se o domínio registrado tem um registro A que aponta para o endereço IP do endereço IPv4 externo global criado na etapa 5. Execute este comando para ver o endereço IP reservado:
```
gcloud compute addresses describe ADDRESS_NAME \
              --format="get(address)" --region=$RUNTIME_LOCATION \
              --project=$PROJECT_ID
```
Se não for possível resolver a configuração do domínio, tente chamar o proxy com este comando:
```
curl  -H Host:DOMAIN --resolve \
  DOMAIN:443:EXTERNAL_IP_ADDRESS  \
  https://DOMAIN:443/hello-world -k
```
Observação: as alterações de DNS são publicadas imediatamente, mas podem levar algum tempo para serem propagadas. Devido a esse atraso, talvez seja necessário aguardar até uma hora para chamar o proxy de amostra.

Próxima: para saber mais sobre como criar e implantar proxies de API, consulte Criar a primeira visão geral do proxy de API.