Provisionar uma organização paga 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, descrevemos como instalar e configurar a Apigee a partir da linha de comando sem peering de VPC. Essas etapas se aplicam aos modelos de preços de assinatura e pagamento por utilização para organizações pagas com ou sem a residência de dados ativada.

Consulte também Opções de provisionamento.

Limitações

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

O VPC Service Controls não é compatível.
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 a identidade de serviço da Apigee: esta conta de serviço é usada pelas bibliotecas de cliente do Google Cloud. para autenticar com as APIs do Google Cloud.
Etapa 4: 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 5: criar uma instância de ambiente de execução: uma instância ou ambiente de execução é o local em que seu projeto e os serviços relacionados são armazenados. Ela fornece o endpoint voltado para o usuário para seus serviços.
Etapa 6: criar um ambiente: um proxy de API precisa ser implantado em um ambiente e adicionado a um grupo de ambientes antes que as APIs expostas fiquem acessíveis pela rede.
Etapa 7: configurar o roteamento: permita o acesso externo ou apenas acesso interno à API.
Etapa 8: implantar um proxy 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ê cumpre os requisitos de configuração listados em Antes de começar.
É preciso ter o SDK do Cloud instalado. Se você precisar instalá-lo, consulte Como instalar o SDK Cloud.
Inicialize o SDK Cloud, conforme descrito em Como inicializar a gcloud CLI ou garanta que o projeto do Google Cloud criado em Pré-requisitos é o projeto padrão para gcloud.
Defina as variáveis de ambiente a seguir no terminal de comando. Selecione a guia que corresponde ao tipo de organização de que você precisa: Sem residência de dados ou com Residência de dados:
Dica: salve as variáveis de ambiente em um arquivo de texto para que possam ser restauradas facilmente se necessário.
Sem residência de dados
```
AUTH="$(gcloud auth print-access-token)"
PROJECT_ID="YOUR_PROJECT_ID"
PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
RUNTIME_LOCATION="YOUR_RUNTIME_LOCATION"
ANALYTICS_REGION="YOUR_ANALYTICS_REGION"
BILLING_TYPE="YOUR_BILLING_TYPE"
```
Observação: se você estiver provisionando uma nova organização da Apigee em um projeto do Google Cloud com uma restrição de local de recursos aplicada em uma política da organização, confirme que a restrição de local está definida como global. Como o plano de controle da Apigee é uma entidade global por padrão, o provisionamento falhará se uma restrição diferente de global for aplicada. Para mais informações, consulte Introdução à residência de dados.

Em que:
- AUTH define o cabeçalho Authentication com um token do portador. Você usará esse cabeçalho ao chamar as APIs Apigee. 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.
- PROJECT_NUMBER é o número 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 que você criará 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 ver uma lista de regiões disponíveis do Apigee API Analytics, consulte Locais da Apigee.
  
  RUNTIME_LOCATION e ANALYTICS_REGION podem ser a mesma região, mas não precisam ser os mesmos.
- BILLING_TYPE é o tipo de faturamento da organização criada. Os valores válidos são:
  - PAYG para organizações com pagamento por utilização.
  - SUBSCRIPTION para organizações com assinatura.
Residência dos dados
```
AUTH="$(gcloud auth print-access-token)"
PROJECT_ID="YOUR_PROJECT_ID"
PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
RUNTIME_LOCATION="YOUR_RUNTIME_LOCATION"
CONTROL_PLANE_LOCATION="YOUR_CONTROL_PLANE_LOCATION"
CONSUMER_DATA_REGION="YOUR_CONSUMER_DATA_REGION"
BILLING_TYPE="YOUR_BILLING_TYPE"
```
Importante: ao usar a residência de dados, o local do plano de controle é a região que o contém. Todas as outras regiões precisam estar no local do plano de controle. Quando o local do plano de controle é us, a região de dados do consumidor e o local do ambiente de execução também precisam estar dentro de us. Por exemplo, us-west1 é aceitável, mas europe-west1 não é.

Em que:
- AUTH define o cabeçalho Authentication com um token do portador. Você usará esse cabeçalho ao chamar as APIs Apigee. 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.
- PROJECT_NUMBER é o número 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 que você criará 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.
  O local do ambiente de execução precisa estar no local do plano de controle.
- CONTROL_PLANE_LOCATION é o local físico em que os dados do plano de controle da Apigee serão armazenados. Para ver uma lista de locais disponíveis do plano de controle, consulte Locais da Apigee.
- CONSUMER_DATA_REGION é uma sub-região da região do plano de controle. Você precisa especificar CONTROL_PLANE_LOCATION e CONSUMER_DATA_REGION. Para ver uma lista de regiões de dados do consumidor disponíveis, consulte Locais da Apigee.
- BILLING_TYPE é o tipo de faturamento da organização criada. Os valores válidos são:
  - PAYG para organizações com pagamento por utilização.
  - SUBSCRIPTION para organizações com assinatura.

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

Sem residência de dados

echo $AUTH
echo $PROJECT_ID
echo $PROJECT_NUMBER
echo $RUNTIME_LOCATION
echo $ANALYTICS_REGION
echo $BILLING_TYPE

As respostas aos comandos echo precisam ser semelhantes a estas:

YOUR_TOKEN
my-cloud-project
1234567890
us-west1
us-west1
SUBSCRIPTION

Residência dos dados

echo $AUTH
echo $PROJECT_ID
echo $PROJECT_NUMBER
echo $RUNTIME_LOCATION
echo $CONTROL_PLANE_LOCATION
echo $CONSUMER_DATA_REGION
echo $BILLING_TYPE

As respostas aos comandos echo precisam ser semelhantes a estas:

YOUR_TOKEN
my-cloud-project
1234567890
us-west1
us
us-west1
SUBSCRIPTION

Etapa 2: ativar as APIs

Permissões exigidas para a tarefa

É possível conceder ao provisionador da Apigee um papel predefinido que inclua as permissões necessárias para realizar essa tarefa ou conceder permissões mais refinadas a fim de 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 \
    compute.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.

Etapa 3: criar a identidade do serviço da Apigee

Crie a identidade do serviço da Apigee:

gcloud beta services identity create --service=apigee.googleapis.com \
  --project=$PROJECT_ID

Verifique se o agente foi criado com sucesso. A resposta precisa mostrar o nome do agente no seguinte formato: service-PROJECT_NUMBER@gcp-sa-apigee.iam.gserviceaccount.com. por exemplo:
```
Service identity created: service-1234567890@gcp-sa-apigee.iam.gserviceaccount.com
```

Etapa 4: criar uma organização

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. Veja estes tópicos:

Antes de criar uma organização, crie um keyring e uma chave de criptografia de banco de dados de ambiente de execução (consulte a etapa 1) e, se estiver usando a residência de dados, os keyrings e as chaves de criptografia do plano de controle (consulte a etapa 2). Essas chaves do Cloud KMS criptografam dados que são armazenados e replicados nos locais do plano de controle e do ambiente de execução. A Apigee usa essas entidades para criptografar dados de aplicativos, como KVMs, cache e chaves secretas do cliente, que são armazenados no banco de dados. Para mais informações, consulte Sobre as chaves de criptografia da Apigee.

Crie um keyring e uma chave de criptografia do banco de dados do ambiente de execução.
1. Defina uma variável de ambiente para o local do keyring e da chave de criptografia do banco de dados do ambiente de execução. Isso ajuda a garantir a consistência quando na criação e facilita o acompanhamento na documentação.
  
  O valor é o local físico em que o keyring e a chave de criptografia do banco de dados são armazenados.
  Região única
  
  Configurações de região única, em que você tem apenas uma instância em uma região: escolha entre os locais regionais do KMS.
  
  Exemplo:
```
RUNTIMEDBKEY_LOCATION="us-west1"
```
  O valor pode ser o mesmo que $RUNTIME_LOCATION (também uma região), mas não precisa ser. No entanto, isso poderá resultar em uma melhoria no desempenho.
  Multirregião
  
  Configurações multirregionais: escolha entre os locais multirregionais compatíveis (como us ou europe) ou locais birregionais.
  
  Exemplo:
```
RUNTIMEDBKEY_LOCATION="us"
```
  Se você tiver uma configuração multirregional nos EUA, recomendamos usar us como seu local, se possível. Do contrário, use nam4.
2. Defina variáveis de ambiente para keyrings e nomes de chaves de bancos de dados.
  O nome do keyring precisa ser exclusivo para sua organização. Se você criar uma segunda ou uma região subsequente, o nome não poderá ser igual ao de outros keyrings.
```
RUNTIMEDB_KEY_RING_NAME=YOUR_DB_KEY_RING_NAME
RUNTIMEDB_KEY_NAME=YOUR_DB_KEY_NAME
```
3. (Opcional) Verifique seu trabalho incluindo os valores que você acabou de definir. Quando quiser usar uma variável nos comandos, lembre-se de colocar o cifrão ($) antes do nome dela.
```
echo $RUNTIMEDBKEY_LOCATION
echo $RUNTIMEDB_KEY_RING_NAME
echo $RUNTIMEDB_KEY_NAME
```
4. Crie um novo keyring:
```
gcloud kms keyrings create $RUNTIMEDB_KEY_RING_NAME \
  --location $RUNTIMEDBKEY_LOCATION --project $PROJECT_ID
```
  O local da chave de criptografia do banco de dados da Apigee é compatível com todos os locais do Cloud KMS compatíveis com o Cloud HSM e o Cloud EKM.
5. Crie uma chave
```
gcloud kms keys create $RUNTIMEDB_KEY_NAME \
  --keyring $RUNTIMEDB_KEY_RING_NAME \
  --location $RUNTIMEDBKEY_LOCATION \
  --purpose "encryption" \
  --project $PROJECT_ID
```
  Esse comando cria a chave e a adiciona ao keyring.
  
  Consiga o ID da chave:
```
gcloud kms keys list \
  --location=$RUNTIMEDBKEY_LOCATION \
  --keyring=$RUNTIMEDB_KEY_RING_NAME \
  --project=$PROJECT_ID
```
  O ID da chave tem a seguinte sintaxe (semelhante a um caminho de arquivo):
```
projects/PROJECT_ID/locations/RUNTIMEDBKEY_LOCATION/keyRings/RUNTIMEDB_KEY_RING_NAME/cryptoKeys/RUNTIMEDB_KEY_NAME
```
6. Coloque o ID da chave em uma variável de ambiente. Você vai usar essa variável em um comando futuro:
```
RUNTIMEDB_KEY_ID=YOUR_RUNTIMEDB_KEY_ID
```
7. Conceda acesso ao agente de serviço da Apigee para usar a nova chave:
```
gcloud kms keys add-iam-policy-binding $RUNTIMEDB_KEY_NAME \
  --location $RUNTIMEDBKEY_LOCATION \
  --keyring $RUNTIMEDB_KEY_RING_NAME \
  --member serviceAccount:service-$PROJECT_NUMBER@gcp-sa-apigee.iam.gserviceaccount.com \
  --role roles/cloudkms.cryptoKeyEncrypterDecrypter \
  --project $PROJECT_ID
```
  Esse comando vincula a chave ao agente de serviços da Apigee.
  
  Após a conclusão dessa solicitação, gcloud responde com algo semelhante ao seguinte:
```
Updated IAM policy for key [runtime].
bindings:
- members:
  - serviceAccount:service-1234567890@gcp-sa-apigee.iam.gserviceaccount.com
  role: roles/cloudkms.cryptoKeyEncrypterDecrypter
etag: BwWqgEuCuwk=
version: 1
```
  Se você receber um erro como este:
```
INVALID_ARGUMENT: Role roles/cloudkms.cryptokms.cryptoKeyEncrypterDecrypter is not supported for this resource.
```
  Verifique se você usou o número do projeto e não o nome do projeto no endereço de e-mail da conta de serviço.
Se você estiver usando a residência de dados, crie um keyring e uma chave de criptografia de plano de controle. Se você não estiver usando a residência de dados, avance para a etapa 3.
Observação: essa etapa só será necessária se você tiver selecionado us (multiple regions in us) ou eu (multiple regions in European Union) como o local de hospedagem do plano de controle. Se você selecionou outra região, prossiga para a etapa 3.

Siga as etapas a seguir para criar um keyring e uma chave de criptografia de plano de controle.

Defina uma variável de ambiente para o local do keyring e da chave de criptografia do banco de dados do plano de controle:
```
CONTROL_PLANE_LOCATION=YOUR_CONTROL_PLANE_LOCATION
CONSUMER_DATA_REGION=YOUR_CONSUMER_DATA_REGION
```
Em que:
- CONTROL_PLANE_LOCATION é o local físico em que os dados do plano de controle da Apigee serão armazenados. Para ver uma lista de locais disponíveis do plano de controle, consulte Locais da Apigee.
- CONSUMER_DATA_REGION é uma sub-região da região do plano de controle. Você precisa especificar CONTROL_PLANE_LOCATION e CONSUMER_DATA_REGION. Para ver uma lista de regiões de dados do consumidor disponíveis, consulte Locais da Apigee.
Defina variáveis de ambiente para os nomes de chaves e keyrings do banco de dados do plano de controle.

O nome do keyring precisa ser exclusivo para sua organização.
```
CONTROL_PLANE_KEY_RING_NAME=YOUR_CONTROL_PLANE_KEY_RING_NAME
CONTROL_PLANE_KEY_NAME=YOUR_CONTROL_PLANE_KEY_NAME
CONSUMER_DATA_KEY_RING_NAME=YOUR_CONSUMER_DATA_KEY_RING_NAME
CONSUMER_DATA_KEY_NAME=YOUR_CONSUMER_DATA_REGION_KEY_NAME
```
Em que:
- CONTROL_PLANE_KEY_RING_NAME é o nome do keyring que você usará para identificar seu keyring de criptografia do plano de controle.
- CONTROL_PLANE_KEY_NAME é o nome da chave que você usará para identificar sua chave de criptografia do plano de controle.
- CONSUMER_DATA_KEY_RING_NAME é o nome do keyring que você usará para identificar seu keyring de criptografia da região de dados do consumidor.
- CONSUMER_DATA_KEY_NAME é o nome da chave que você usará para identificar sua chave de criptografia da região de dados do consumidor.

Crie um novo keyring:

gcloud kms keyrings create $CONTROL_PLANE_KEY_RING_NAME \
  --location $CONTROL_PLANE_LOCATION \
  --project $PROJECT_ID

gcloud kms keyrings create $CONSUMER_DATA_KEY_RING_NAME \
  --location $CONSUMER_DATA_REGION \
  --project $PROJECT_ID

Crie uma chave

gcloud kms keys create $CONTROL_PLANE_KEY_NAME \
  --keyring $CONTROL_PLANE_KEY_RING_NAME \
  --location $CONTROL_PLANE_LOCATION \
  --purpose "encryption" \
  --project $PROJECT_ID

gcloud kms keys create $CONSUMER_DATA_KEY_NAME \
  --keyring $CONSUMER_DATA_KEY_RING_NAME \
  --location $CONSUMER_DATA_REGION \
  --purpose "encryption" \
  --project $PROJECT_ID

Esse comando cria a chave e a adiciona ao keyring.

Consiga o ID da chave:

gcloud kms keys list \
--location=$CONTROL_PLANE_LOCATION \
--keyring=$CONTROL_PLANE_KEY_RING_NAME \
--project=$PROJECT_ID

gcloud kms keys list \
--location=$CONSUMER_DATA_REGION \
--keyring=$CONSUMER_DATA_KEY_RING_NAME \
--project=$PROJECT_ID

O ID da chave tem a seguinte sintaxe (semelhante a um caminho de arquivo):

projects/PROJECT_ID/locations/CONTROL_PLANE_LOCATION/keyRings/CONTROL_PLANE_KEY_RING_NAME/cryptoKeys/CONTROL_PLANE_KEY_NAME

projects/PROJECT_ID/locations/CONSUMER_DATA_REGION/keyRings/CONSUMER_DATA_KEY_RING_NAME/cryptoKeys/CONSUMER_DATA_KEY_NAME

Coloque o ID da chave em uma variável de ambiente. Você vai usar essa variável em um comando futuro:
```
CONTROL_PLANE_KEY_ID=YOUR_CONTROL_PLANE_KEY_ID
```
```
CONSUMER_DATA_KEY_ID=YOUR_CONSUMER_DATA_KEY_ID
```

Conceda acesso ao agente de serviço da Apigee para usar a nova chave:

gcloud kms keys add-iam-policy-binding $CONTROL_PLANE_KEY_NAME \
  --location $CONTROL_PLANE_LOCATION \
  --keyring $CONTROL_PLANE_KEY_RING_NAME \
  --member "serviceAccount:service-$PROJECT_NUMBER@gcp-sa-apigee.iam.gserviceaccount.com" \
  --role roles/cloudkms.cryptoKeyEncrypterDecrypter \
  --project $PROJECT_ID

gcloud kms keys add-iam-policy-binding $CONSUMER_DATA_KEY_NAME \
 --location $CONSUMER_DATA_REGION \
 --keyring $CONSUMER_DATA_KEY_RING_NAME \
 --member "serviceAccount:service-$PROJECT_NUMBER@gcp-sa-apigee.iam.gserviceaccount.com" \
 --role roles/cloudkms.cryptoKeyEncrypterDecrypter \
 --project $PROJECT_ID

Esse comando vincula a chave ao agente de serviços da Apigee. Após a conclusão dessa solicitação, a gcloud responde com algo semelhante a isto:

Updated IAM policy for key [runtime].
bindings:
- members:
  - serviceAccount:service-1234567890@gcp-sa-apigee.iam.gserviceaccount.com
  role: roles/cloudkms.cryptoKeyEncrypterDecrypter
etag: BwWqgEuCuwk=
version: 1

Se você receber um erro como este:

INVALID_ARGUMENT: Role roles/cloudkms.cryptokms.cryptoKeyEncrypterDecrypter is not supported for this resource.

Verifique se você usou o número do projeto e não o nome do projeto no endereço de e-mail da conta de serviço.

Consulte também: Solução de problemas de CMEK.

Crie a organização enviando a seguinte solicitação à API Organizations da Apigee:
Sem residência de dados
```
curl "https://apigee.googleapis.com/v1/organizations?parent=projects/$PROJECT_ID"  \
  -H "Authorization: Bearer $AUTH" \
  -X POST \
  -H "Content-Type:application/json" \
  -d '{
    "name":"'"$PROJECT_ID"'",
    "analyticsRegion":"'"$ANALYTICS_REGION"'",
    "runtimeType":"CLOUD",
    "billingType":"'"$BILLING_TYPE"'",
    "disableVpcPeering":"true",
    "runtimeDatabaseEncryptionKeyName":"'"$RUNTIMEDB_KEY_ID"'"
  }'
```
Em que:
- -d define o payload de dados para a solicitação. Esse payload precisa incluir o seguinte:
  - name: identifica a nova organização. Ele precisa ter o mesmo nome do ID do projeto.
  - analyticsRegion: especifica o local físico em que os dados de análise serão armazenados.
  - runtimeType: Defina esse valor como CLOUD.
  - billingType: especifica o tipo de faturamento da organização criado.
  - disableVpcPeering: defina como true se você não quiser usar o peering de VPC. Padrão: false
  - runtimeDatabaseEncryptionKeyName: o ID da chave de criptografia do aplicativo que você criou no passo anterior. Lembre-se de que o ID é estruturado como um caminho de arquivo. Por exemplo:
    projects/my-project/locations/us-west1/keyRings/my-key-ring/cryptoKeys/my-key
Residência dos dados

Crie uma organização usando a API:
```
curl "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations?parent=projects/$PROJECT_ID"  \
  -H "Authorization: Bearer $AUTH" \
  -X POST \
  -H "Content-Type:application/json" \
  -d '{
    "name":"'"$PROJECT_ID"'",
    "runtimeType":"CLOUD",
    "billingType":"'"$BILLING_TYPE"'",
    "controlPlaneEncryptionKeyName":"'"$CONTROL_PLANE_KEY_ID"'",
    "apiConsumerDataLocation":"'"$CONSUMER_DATA_REGION"'",
    "apiConsumerDataEncryptionKeyName":"'"$CONSUMER_DATA_KEY_ID"'",
    "disableVpcPeering":"true",
    "runtimeDatabaseEncryptionKeyName":"'"$RUNTIMEDB_KEY_ID"'"
  }'
```
Em que:

-d define o payload de dados para a solicitação. Esse payload precisa incluir os seguintes dados:
- name: identifica a nova organização. Ele precisa ter o mesmo nome do ID do projeto.
- runtimeType: Defina esse valor como CLOUD.
- billingType: especifica o tipo de faturamento da organização criado.
- controlPlaneEncryptionKeyName: é o ID da chave do plano de controle.
- apiConsumerDataLocation: também é preciso especificar uma sub-região para uso de recursos internos. Consulte Regiões de residência de dados para conferir os valores aceitos.
- apiConsumerDataEncryptionKeyName: é o ID da chave da região de dados do consumidor.
- disableVpcPeering: defina como true se você não quiser usar o peering de VPC. Padrão: false
- runtimeDatabaseEncryptionKeyName: o ID da chave de criptografia do aplicativo que você criou no passo anterior. O ID é estruturado como um caminho de arquivo. Por exemplo:
  projects/my-project/locations/us-west1/keyRings/my-key-ring/cryptoKeys/my-key
Depois que você executar esse comando, a Apigee iniciará uma operação de longa duração, que pode levar alguns minutos para ser concluída.

Se você receber um erro, verifique se colocou os valores das variáveis entre aspas no payload de dados. Coloque a variável $PROJECT_ID entre aspas duplas e simples, conforme mostrado no exemplo a seguir:
```
"'"$PROJECT_ID"'"
```
Se você usar strings simples (não variáveis de ambiente) como valores de solicitação, coloque-as entre aspas duplas dentro da string de payload entre aspas simples, como no exemplo abaixo:
```
'{ "name":"my-gcp-project", ... }'
```
Aguarde alguns minutos.
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:
Sem residência de dados
```
curl -H "Authorization: Bearer $AUTH" "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID"
```
Residência dos dados
```
curl -H "Authorization: Bearer $AUTH" "https://$CONTROL_PLANE_LOCATION-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.

Se a Apigee retornar uma resposta de erro HTTP, consulte Como criar uma organização da Apigee.

Dica: para listar as organizações da Apigee e os projetos do Google Cloud associados que você tem permissão para acessar, envie uma solicitação GET para o endpoint a seguir usando a API Organizations:

Sem residência de dados:

curl -H "Authorization: Bearer $AUTH" https://apigee.googleapis.com/v1/organizations/

Residência de dados:

curl -H "Authorization: Bearer $AUTH" https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/

A Apigee retorna uma lista de projetos, como mostrado no exemplo a seguir:

{
  "organizations": [
    {
      "organization": "my-cloud-project",
      "projectIds": [
        "my-cloud-project"
      ],
      "projectId": "my-cloud-project",
      "location": "northamerica-northeast1"
    },
    {
      "organization": "my-cloud-project-2",
      "projectIds": [
        "my-cloud-project-2"
      ],
      "projectId": "my-cloud-project-2",
      "location": "northamerica-northeast1"
    }
  ]
}

Etapa 5: criar uma instância de ambiente de execução

Permissões exigidas para a tarefa

Uma instância de ambiente de execução é onde seu projeto da Apigee e os serviços relacionados são armazenados. Ela fornece o endpoint voltado ao usuário para seus serviços. Para criar uma nova instância de ambiente de execução:

Verifique se a Apigee terminou de criar sua organização. Você enviou uma solicitação para criar uma nova organização em Criar uma organização da Apigee, mas é preciso verificar se ela está concluída antes de continuar.

Para isso, envie a seguinte solicitação à API Organizations:
Sem residência de dados
```
curl -i -H "Authorization: Bearer $AUTH" \
    "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID"
```
Residência dos dados
```
curl -i -H "Authorization: Bearer $AUTH" \
    "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID"
```
Se a organização existir e você tiver as permissões adequadas para visualizá-la, a Apigee responderá com detalhes sobre ela. Se a Apigee responder com um erro, aguarde alguns minutos e envie a solicitação novamente.
Assim como na tarefa anterior, em que foi criada uma chave de criptografia para o banco de dados, agora você precisa criar uma chave do Cloud KMS usada para criptografar dados do lado do servidor. Para começar, defina as seguintes variáveis de ambiente:
```
INSTANCE_NAME=YOUR_INSTANCE_NAME
RUNTIME_LOCATION=YOUR_RUNTIME_LOCATION
DISK_KEY_RING_NAME=YOUR_DISK_KEY_RING_NAME
DISK_KEY_NAME=YOUR_DISK_KEY_NAME
```

Em que:

INSTANCE_NAME: o nome da sua nova instância. Por exemplo, my-runtime-instance. O nome precisa começar com uma letra minúscula, ter até 32 caracteres e incluir apenas letras minúsculas, números e hífens. Ele não pode começar nem terminar com um hífen e precisa ter pelo menos dois caracteres.
Dica: o nome da instância precisa corresponder à seguinte expressão regular:
```
^[a-z][a-z\-\d]{0,30}[a-z\d]$
```
RUNTIME_LOCATION é o lugar físico em que o cluster está hospedado. Os valores válidos são qualquer local permitido pelo Compute Engine. Consulte regiões e zonas disponíveis. O exemplo usa us-west1.
DISK_KEY_RING_NAME é o nome do keyring de criptografia do disco.
DISK_KEY_NAME é o nome da chave de criptografia do disco.

Crie uma chave de criptografia de disco:

Crie um novo keyring de disco:
```
gcloud kms keyrings create $DISK_KEY_RING_NAME \
  --location $RUNTIME_LOCATION \
  --project $PROJECT_ID
```
O keyring de disco precisa ser definido como o mesmo local da instância. Cada instância e keyring têm o próprio local.

Crie uma nova chave de disco:

gcloud kms keys create $DISK_KEY_NAME \
  --keyring $DISK_KEY_RING_NAME \
  --location $RUNTIME_LOCATION \
  --purpose "encryption" \
  --project $PROJECT_ID

A chave pode ser referenciada pelo caminho de chave. É possível ver o caminho da chave com o comando a seguir:

gcloud kms keys list \
  --location=$RUNTIME_LOCATION \
  --keyring=$DISK_KEY_RING_NAME \
  --project=$PROJECT_ID

O caminho da chave é semelhante a este:

projects/PROJECT_ID/locations/RUNTIME_LOCATION/keyRings/my-disk-key-ring/cryptoKeys/my-disk-key

Coloque o caminho da chave em uma variável de ambiente. Você usará essa variável em um comando futuro:
```
DISK_KEY_ID=YOUR_DISK_KEY_ID
```
Por exemplo: DISK_KEY_ID=projects/my-project/locations/us-west1/keyRings/my-key-ring/cryptoKeys/my-key

Conceda acesso ao agente de serviço da Apigee para usar a nova chave:

gcloud kms keys add-iam-policy-binding $DISK_KEY_NAME \
  --location $RUNTIME_LOCATION \
  --keyring $DISK_KEY_RING_NAME \
  --member serviceAccount:service-$PROJECT_NUMBER@gcp-sa-apigee.iam.gserviceaccount.com \
  --role roles/cloudkms.cryptoKeyEncrypterDecrypter \
  --project $PROJECT_ID

Esse comando vincula a chave ao agente de serviços da Apigee.

Para mais informações, consulte Sobre as chaves de criptografia da Apigee.

Crie uma nova instância de ambiente de execução para seu projeto enviando uma solicitação POST para a API Instances da Apigee:
Sem residência de dados
```
curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances" \
  -X POST -H "Authorization: Bearer $AUTH" \
  -H "Content-Type:application/json" \
  -d '{
    "name":"'"$INSTANCE_NAME"'",
    "location":"'"$RUNTIME_LOCATION"'",
    "diskEncryptionKeyName":"'"$DISK_KEY_ID"'",
    "consumerAcceptList":["'"$PROJECT_ID"'"]
  }'
```
Residência dos dados
```
curl "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances" \
  -X POST -H "Authorization: Bearer $AUTH" \
  -H "Content-Type:application/json" \
  -d '{
    "name":"'"$INSTANCE_NAME"'",
    "location":"'"$RUNTIME_LOCATION"'",
    "diskEncryptionKeyName":"'"$DISK_KEY_ID"'",
    "consumerAcceptList":["'"$PROJECT_ID"'"]
  }'
```
Em que:
- consumerAcceptList (opcional) especifica uma lista de IDs de projetos do Google Cloud que podem se conectar de maneira particular ao anexo de serviço da VPC da Apigee. O anexo de serviço é uma entidade usada com o Private Service Connect do Google Cloud para permitir que os produtores de serviços (neste caso, a Apigee) exponham serviços aos consumidores (neste caso, um ou mais projetos do Cloud que pertencem a você). Por padrão, usamos o projeto do Cloud que já está associado à sua organização da Apigee. Por exemplo: "consumerAcceptList": ["project1", "project2", "project3"]
  Também é possível definir e alterar a lista de projetos aceitos na interface da instância. Para mais detalhes, consulte Como gerenciar instâncias.
Essa solicitação pode levar até 20 minutos para ser concluída porque a Apigee precisa criar e iniciar um novo cluster do Kubernetes, instalar os recursos da Apigee nesse cluster e configurar o balanceamento de carga.

Se a Apigee retornar um erro, consulte Como criar uma nova instância.

Para ver o status da solicitação de criação da instância de ambiente de execução, execute o comando a seguir. Quando o estado for ACTIVE, avance para a próxima etapa.

Sem residência de dados

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

Residência dos dados

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

Etapa 6: criar um ambiente

Permissões exigidas para a tarefa

Para criar um ambiente e anexá-lo ao ambiente de execução na linha de comando:

Defina as variáveis de ambiente a serem usadas nesta seção: As variáveis específicas de ambiente que você cria dependem de se você está criando um ambiente para uma assinatura ou um pagamento por utilização. org.
Inscrição

Para um ambiente de assinatura, crie estas variáveis:
```
ENVIRONMENT_NAME="YOUR_ENV_NAME"
ENV_GROUP_NAME="YOUR_ENV_GROUP_NAME"
ENV_GROUP_HOSTNAME="YOUR_ENV_GROUP_HOSTNAME"
```
Em que:
- ENVIRONMENT_NAME é um nome de string. Por exemplo: test
- ENV_GROUP_NAME é um nome de string. Por exemplo: test-group
- ENV_GROUP_HOSTNAME é um nome de host de domínio válido. Por exemplo: foo.example.com
Pagamento por utilização

Para um ambiente de pagamento por utilização, crie estas variáveis:
```
ENVIRONMENT_NAME="YOUR_ENV_NAME"
ENVIRONMENT_TYPE="YOUR_ENV_TYPE"
ENV_GROUP_NAME="YOUR_ENV_GROUP_NAME"
ENV_GROUP_HOSTNAME="YOUR_ENV_GROUP_HOSTNAME"
```
Em que:
- ENVIRONMENT_NAME é um nome de string. Por exemplo: test
- ENVIRONMENT_TYPE é o tipo desse ambiente e só é aplicável a usuários de pagamento por uso, que precisam especificar um destes valores: BASE, INTERMEDIATE ou COMPREHENSIVE. Outros usuários precisam omitir o tipo de ambiente.
- ENV_GROUP_NAME é um nome de string. Por exemplo: test-group
- ENV_GROUP_HOSTNAME é um nome de host de domínio válido. Por exemplo: foo.example.com

Crie um novo ambiente com os Ambientes API Os comandos específicos que você usa dependem da criação de um ambiente para uma organização de assinatura ou de pagamento por utilização.

Inscrição

Para um novo ambiente de assinatura, use o seguinte comando:

Sem residência de dados

curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments" \
    -H "Authorization: Bearer $AUTH" \
    -X POST \
    -H "Content-Type:application/json" \
    -d '{
      "name":"'"$ENVIRONMENT_NAME"'"
  }'

Residência dos dados

curl "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments" \
    -H "Authorization: Bearer $AUTH" \
    -X POST \
    -H "Content-Type:application/json" \
    -d '{
      "name":"'"$ENVIRONMENT_NAME"'"
  }'

A Apigee cria um novo ambiente.

Pagamento por utilização

Para um novo ambiente de pagamento por utilização, use o seguinte comando:

Sem residência de dados

curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments" \
    -H "Authorization: Bearer $AUTH" \
    -X POST \
    -H "Content-Type:application/json" \
    -d '{
      "name":"'"$ENVIRONMENT_NAME"'",
      "type":"'"$ENVIRONMENT_TYPE"'"
  }'

Residência dos dados

curl "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments" \
    -H "Authorization: Bearer $AUTH" \
    -X POST \
    -H "Content-Type:application/json" \
    -d '{
      "name":"'"$ENVIRONMENT_NAME"'",
      "type":"'"$ENVIRONMENT_TYPE"'"
  }'

A Apigee cria um novo ambiente.

Antes de continuar, verifique se a Apigee concluiu a criação do novo ambiente chamando a API Environments:

Sem residência de dados

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

Residência dos dados

curl -i -H "Authorization: Bearer $AUTH" \
    "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments"

A Apigee responde com uma lista de ambientes disponíveis. Por exemplo, se o nome do ambiente for test, a Apigee responderá com o seguinte:

[
  "test"
]

Dica: verifique o status de um ambiente específico enviando um comando como este:

Sem residência de dados:

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

Residência de dados:

curl -i -X GET -H "Authorization: Bearer $AUTH" \
              "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments/$ENVIRONMENT_NAME"

A Apigee responde com detalhes apenas sobre esse ambiente. Por exemplo:

{
  "name": "my-cloud-project",
  "createdAt": "1592589683002",
  "lastModifiedAt": "1592589683002",
  "state": "ACTIVE"
}

Anexe o novo ambiente à instância de ambiente de execução:

Sem residência de dados

curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances/$INSTANCE_NAME/attachments" \
    -X POST -H "Authorization: Bearer $AUTH" \
    -H "content-type:application/json" \
    -d '{
      "environment":"'"$ENVIRONMENT_NAME"'"
    }'

Residência dos dados

curl "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances/$INSTANCE_NAME/attachments" \
    -X POST -H "Authorization: Bearer $AUTH" \
    -H "content-type:application/json" \
    -d '{
      "environment":"'"$ENVIRONMENT_NAME"'"
    }'

Essa operação pode levar vários minutos para ser concluída. Para conferir se a operação foi concluída, execute este comando:

Sem residência de dados

curl -i -H "Authorization: Bearer $AUTH" \
  "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances/$INSTANCE_NAME/attachments"

Residência dos dados

curl -i -H "Authorization: Bearer $AUTH" \
  "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/instances/$INSTANCE_NAME/attachments"

Ao ver uma saída como esta, avance para o próximo passo:

{
  "attachments": [
    {
      "name": "ed628782-c893-4095-b71c-f4731805290a",
      "environment": "test",
      "createdAt": "1641604447542"
    }
  ]
}

Crie um novo grupo de ambiente usando o seguinte comando: Saiba mais em Sobre ambientes e grupos de ambientes:

Sem residência de dados

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

Residência dos dados

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

Aguarde a conclusão da operação. Verifique o status do novo grupo usando uma solicitação como esta:

Sem residência de dados

curl -i -H "Authorization: Bearer $AUTH" \
    "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups/$ENV_GROUP_NAME"

Residência dos dados

curl -i -H "Authorization: Bearer $AUTH" \
    "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups/$ENV_GROUP_NAME"

Anexe o novo ambiente ao novo grupo de ambiente com o seguinte comando:

Sem residência de dados

curl "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups/$ENV_GROUP_NAME/attachments" \
    -X POST \
    -H "Authorization: Bearer $AUTH" \
    -H "content-type:application/json" \
    -d '{
      "environment":"'"$ENVIRONMENT_NAME"'"
  }'

Residência dos dados

curl "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups/$ENV_GROUP_NAME/attachments" \
    -X POST \
    -H "Authorization: Bearer $AUTH" \
    -H "content-type:application/json" \
    -d '{
      "environment":"'"$ENVIRONMENT_NAME"'"
  }'

Para ver o status da operação, chame esta API:

Sem residência de dados

curl -H "Authorization: Bearer $AUTH" \
    "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups/$ENV_GROUP_NAME/attachments"

Residência dos dados

curl -H "Authorization: Bearer $AUTH" \
    "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups/$ENV_GROUP_NAME/attachments"

Etapa 7: 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 são as seguintes. Acesse a opção de configuração que quer usar e execute as etapas para essa opção:

Tipo de acesso	Descrição do processo de configuração e implantação
Interno com o PSC (novo)	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 PSC (novo)	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 (novo)

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 PSC (novo)

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 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 de serviço da instância criada anteriormente:

Sem residência de dados

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

Residência dos dados

curl -i -X GET -H "Authorization: Bearer $AUTH" \
"https://$CONTROL_PLANE_LOCATION-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.
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: observe as 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.
O número de projetos do Google Cloud que podem se conectar a uma instância da Apigee pela PSC é limitado a 50, e cada projeto pode criar até 20 conexões. Consulte Configurar roteamento. Veja também Limites.
Observação: você controla a lista de projetos do Google Cloud conectados a uma instância no campo consumerAcceptList da API de instâncias.
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:

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 de 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:

Sem residência de dados

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

Residência dos dados

curl -i -X GET -H "Authorization: Bearer $AUTH" \
"https://$CONTROL_PLANE_LOCATION-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
```
Em que $PROJECT_ID pode ser 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.

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 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:

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

Para criar um balanceador de carga 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 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 poder 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.
O número de projetos do Google Cloud que podem se conectar a uma instância da Apigee pela PSC é limitado a 50, e cada projeto pode criar até 20 conexões. Consulte Configurar roteamento. Veja também Limites.
Observação: você controla a lista de projetos do Google Cloud conectados a uma instância no campo consumerAcceptList da API de instâncias.
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:

Sem residência de dados

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

Residência dos dados

curl -i -X GET -H "Authorization: Bearer $AUTH" \
    "https://$CONTROL_PLANE_LOCATION-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:
- NEG_NAME: um nome para o grupo de endpoints da rede.
- TARGET_SERVICE: o anexo de serviço ao qual você quer se conectar. Use o valor do anexo do serviço retornado pelo comando anterior. 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.
- $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. Se você ainda não fez isso, crie uma variável de ambiente para manter o ID do projeto, porque ela é usada na maioria dos comandos a seguir.

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.

Para criar um balanceador de carga 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.

Balanceador de carga externo regional

Configure um balanceador de carga HTTP(S) externo regional. Consulte também Visão geral 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: o nome da sub-rede.
- NETWORK_NAME (opcional): o nome da rede 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:

Sem residência de dados

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

Residência dos dados

curl -i -X GET -H "Authorization: Bearer $AUTH" \
    "https://$CONTROL_PLANE_LOCATION-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.

Para criar um balanceador de carga 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 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.
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 Implantar um proxy de amostra.

Etapa 8: implantar um proxy de amostra

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 podem ser implantados, consulte Papéis da Apigee.

Faça o download do proxy de amostra pelo GitHub. O destino do proxy é o serviço httpbin.org, que é um serviço público de solicitação e resposta usado com frequência.

Faça upload do pacote do proxy de API no ambiente de execução usando a API apis da Apigee:

Sem residência de dados

curl -i -X POST -H "Authorization: Bearer $AUTH" \
    -H "Content-Type:multipart/form-data" \
    "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/apis?name=httpbin&action=import" \
    -F 'file=@PATH_TO_ZIP_FILE/httpbin_rev1_2020_02_02.zip'

Residência dos dados

curl -i -X POST -H "Authorization: Bearer $AUTH" \
    -H "Content-Type:multipart/form-data" \
    "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/apis?name=httpbin&action=import" \
    -F 'file=@PATH_TO_ZIP_FILE/httpbin_rev1_2020_02_02.zip'

Em que PATH_TO_ZIP_FILE é o caminho para o diretório que contém o arquivo ZIP salvo.

Implante o proxy de API no ambiente que você criou anteriormente:

Sem residência de dados

curl -i -H "Authorization: Bearer $AUTH" -X POST \
    "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments/$ENVIRONMENT_NAME/apis/httpbin/revisions/1/deployments"

Residência dos dados

curl -i -H "Authorization: Bearer $AUTH" -X POST \
    "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments/$ENVIRONMENT_NAME/apis/httpbin/revisions/1/deployments"

Confirme se a implantação foi concluída com esta chamada de API:

Sem residência de dados

curl -i -H "Authorization: Bearer $AUTH" \
    "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments/$ENVIRONMENT_NAME/apis/httpbin/revisions/1/deployments"

Residência dos dados

curl -i -H "Authorization: Bearer $AUTH" \
    "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/environments/$ENVIRONMENT_NAME/apis/httpbin/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: ENV_GROUP_HOSTNAME" \
    "https://ENV_GROUP_HOSTNAME/httpbin/headers"

Se necessário, use essa API para conseguir o valor ENV_GROUP_HOSTNAME:

Sem residência de dados

curl -i -H "Authorization: Bearer $AUTH" \
    "https://apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups"

Residência dos dados

curl -i -H "Authorization: Bearer $AUTH" \
    "https://$CONTROL_PLANE_LOCATION-apigee.googleapis.com/v1/organizations/$PROJECT_ID/envgroups"

Se você receber um erro como CONNECT_CR_SRVR_HELLO:sslv3 alert handshake failure, verifique se o certificado SSL criado foi provisionado. Use este comando para verificar o status de provisionamento. Quando o certificado é provisionado, o status é ACTIVE.

gcloud compute ssl-certificates describe CERTIFICATE \
    --global \
    --format="get(name,managed.status, managed.Status)"

Após a conclusão, o proxy de API de amostra retorna uma resposta semelhante a esta:

{
    "headers": {
      "Accept": "*/*",
      "Grpc-Trace-Bin": "AAD/8WC/I4AUSrMEch0E9yj+AYck1x9afwckAgA",
      "Host": "httpbin.org",
      "Traceparent": "00-fff160bf2380144ab304721d04f728fe-8724d71f5a7f0724-00",
      "User-Agent": "curl/7.77.0",
      "X-Amzn-Trace-Id": "Root=1-61d785ef-7613aa8a7fde7a910441fab9",
      "X-B3-Sampled": "0",
      "X-B3-Spanid": "8724d71f5a7f0724",
      "X-B3-Traceid": "fff160bf2380144ab304721d04f728fe",
      "X-Cloud-Trace-Context": "fff160bf2380144ab304721d04f728fe/9738144823944087332;o=0",
      "X-Envoy-Attempt-Count": "1"
    }
}

Saiba mais sobre como implantar proxies, incluindo informações extras sobre solução de problemas em Como implantar um proxy de API.

Provisionar uma organização paga sem peering de VPC

Limitações

Resumo das etapas

Etapa 1: definir variáveis de ambiente

Sem residência de dados

Residência dos dados

Sem residência de dados

Residência dos dados

Etapa 2: ativar as APIs

Permissões exigidas para a tarefa

Etapa 3: criar a identidade do serviço da Apigee

Etapa 4: criar uma organização

Permissões exigidas para a tarefa

Região única

Multirregião

Sem residência de dados

Residência dos dados

Sem residência de dados

Residência dos dados

Etapa 5: criar uma instância de ambiente de execução

Permissões exigidas para a tarefa

Sem residência de dados

Residência dos dados

Sem residência de dados

Residência dos dados

Sem residência de dados

Residência dos dados

Etapa 6: criar um ambiente

Permissões exigidas para a tarefa

Inscrição

Pagamento por utilização

Inscrição

Sem residência de dados

Residência dos dados

Pagamento por utilização

Sem residência de dados

Residência dos dados

Sem residência de dados

Residência dos dados

Sem residência de dados

Residência dos dados

Sem residência de dados

Residência dos dados

Sem residência de dados

Residência dos dados

Sem residência de dados

Residência dos dados

Sem residência de dados

Residência dos dados

Sem residência de dados

Residência dos dados

Etapa 7: configurar o roteamento

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

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

Sem residência de dados

Residência dos dados

Balanceador de carga interno regional

Permissões exigidas para a tarefa

Etapa 8a: configurar as variáveis de ambiente

Etapa 8b: criar uma sub-rede somente proxy

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

Sem residência de dados

Residência dos dados

Etapa 8d: configurar o balanceador de carga interno regional

Roteamento externo (PSC)

Permissões exigidas para a tarefa

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

Balanceador de carga externo global

Sem residência de dados

Residência dos dados

Balanceador de carga externo regional

Sem residência de dados

Residência dos dados

Etapa 8: implantar um proxy de amostra

Permissões exigidas para a tarefa

Sem residência de dados

Residência dos dados

Sem residência de dados