Provisionar uma organização paga com 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 com 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.

Resumo das etapas

As etapas de provisionamento são as seguintes:

Etapa 1: definir variáveis de ambiente

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

  1. Verifique se você cumpre os requisitos de configuração listados em Antes de começar.
  2. É preciso ter o SDK do Cloud instalado. Se você precisar instalá-lo, consulte Como instalar o SDK Cloud.
  3. 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.
  4. 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:

    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"

    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.

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

    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"

    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.

      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:

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

  1. 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 \
    servicenetworking.googleapis.com \
    compute.googleapis.com \
    cloudkms.googleapis.com --project=$PROJECT_ID

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

  1. Crie a identidade do serviço da Apigee:

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

  2. 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: configurar a rede de serviços

Nesta etapa, você aloca um par de intervalos de endereços IP (um intervalo CIDR /22 e /28) para a Apigee e executa o peering de VPC entre sua rede e a rede da Apigee. Cada instância da Apigee requer um intervalo CIDR não sobreposto de /22 e /28. O endereço do ambiente de execução da Apigee recebe endereços IP desse intervalo CIDR. Como resultado, é importante que o intervalo seja reservado para a Apigee e não usado por outros aplicativos na rede VPC do cliente. Para mais informações e considerações importantes, consulte Noções básicas sobre intervalos de peering.

Observe que você está criando um intervalo de IP de rede suficiente para uma instância da Apigee. Se você planeja criar outras instâncias da Apigee, repita essa etapa para cada uma. Os intervalos não podem ser compartilhados entre instâncias. Consulte também Como expandir a Apigee para várias regiões.

  1. Crie estas variáveis de ambiente: 
    RANGE_NAME=YOUR_RANGE_NAME
NETWORK_NAME=YOUR_NETWORK_NAME

    Em que:

    • RANGE_NAME é o nome do intervalo de endereços IP que você está criando. Você dá o nome que quiser a ele. Por exemplo: google-svcs
    • NETWORK_NAME é o nome do recurso de rede em que os endereços precisam ser reservados.

      O Google cria uma rede padrão (chamada default) para cada novo projeto, para que você possa usar isso. No entanto, o Google não recomenda usar a rede padrão para qualquer finalidade que não seja teste.

  2. Crie um intervalo de IP de rede com um comprimento CIDR de /22: 
    gcloud compute addresses create $RANGE_NAME \
  --global \
  --prefix-length=22 \
  --description="Peering range for Apigee services" \
  --network=$NETWORK_NAME \
  --purpose=VPC_PEERING \
  --addresses=OPTIONAL_ADDRESSES \
  --project=$PROJECT_ID

    Em que --addresses permite especificar um intervalo de endereços. Por exemplo, para alocar o bloco CIDR 192.168.0.0/22, especifique 192.168.0.0 como endereço e 22 como tamanho de prefixo. Consulte também Como criar uma alocação de IP.

    Se você não fornecer o parâmetro --addresses, a gcloud selecionará um intervalo de endereços disponível.

    Em caso de sucesso, gcloud responderá com o seguinte:

    Created [https://www.googleapis.com/compute/v1/projects/PROJECT_NAME/global/addresses/google-svcs].

    Depois que você criar um intervalo de endereços IP, os endereços serão associados ao projeto até que você os libere.

  3. Verifique se o intervalo de IPs da rede foi criado com um comprimento CIDR de /22: 
    gcloud compute addresses list --global --project=$PROJECT_ID
gcloud compute addresses describe $RANGE_NAME --global --project=$PROJECT_ID
  4. Crie um intervalo de IP de rede com um comprimento CIDR de /28. Esse intervalo é obrigatório e é usado pela Apigee para solução de problemas e não pode ser personalizado ou alterado. 
    gcloud compute addresses create google-managed-services-support-1 \
  --global \
  --prefix-length=28 \
  --description="Peering range for supporting Apigee services" \
  --network=$NETWORK_NAME \
  --purpose=VPC_PEERING \
  --addresses=OPTIONAL_ADDRESSES \
  --project=$PROJECT_ID

    Em que --addresses permite especificar um intervalo de endereços. Por exemplo, para alocar o bloco CIDR 192.168.0.0/28, especifique 192.168.0.0 como endereço e 28 como tamanho de prefixo. Consulte também Como criar uma alocação de IP.

    Se você não fornecer o parâmetro --addresses, a gcloud selecionará um intervalo de endereços disponível.

  5. Verifique se o intervalo de IPs da rede foi criado com um comprimento CIDR de /28: 
    gcloud compute addresses list --global --project=$PROJECT_ID
gcloud compute addresses describe google-managed-services-support-1 --global \
  --project=$PROJECT_ID
  6. Conecte os serviços à VPC usando o seguinte comando: 
    gcloud services vpc-peerings connect \
  --service=servicenetworking.googleapis.com \
  --network=$NETWORK_NAME \
  --ranges=$RANGE_NAME,google-managed-services-support-1 \
  --project=$PROJECT_ID

    Essa operação pode levar vários minutos para ser concluída. Em caso de sucesso, gcloud responde com o seguinte, em que OPERATION_ID é o UUID da LRO.

    Operation "operations/OPERATION_ID" finished successfully.

    7. A Apigee cria uma conexão entre sua VPC e os serviços do Google. Especificamente, a Apigee conecta seu projeto à API Service Networking usando o peering de VPC. A Apigee também associa os endereços IP ao seu projeto.

  7. Após alguns minutos, verifique se o peering de VPC foi bem-sucedido: 
    gcloud services vpc-peerings list \
  --network=$NETWORK_NAME \
  --service=servicenetworking.googleapis.com \
  --project=$PROJECT_ID

Etapa 5: criar uma organização

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.

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

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

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

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

    2. 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.
    3. 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
    4. 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
    5. 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
    6. 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.

  3. 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"'",
    "authorizedNetwork":"'"$NETWORK_NAME"'",
    "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.
      • authorizedNetwork: identifica a rede de peering especificada em Configurar rede de serviço.
      • runtimeDatabaseEncryptionKeyName: o ID da chave de criptografia do aplicativo que você criou na etapa 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"'",
    "authorizedNetwork":"'"$NETWORK_NAME"'",
    "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.
    • authorizedNetwork: identifica a rede de peering especificada em Configurar rede de serviço.
    • runtimeDatabaseEncryptionKeyName: o ID da chave de criptografia do aplicativo que você criou na etapa 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", ... }'
  4. Aguarde alguns minutos.
  5. 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 a Apigee tiver criado uma nova organização, você receberá uma resposta semelhante a esta:

    Sem residência de dados

    {
  "name": "my-cloud-project",
  "createdAt": "1592586495539",
  "lastModifiedAt": "1592586495539",
  "environments": [],
  "properties": {
    "property": [
      {
        "name": "features.hybrid.enabled",
        "value": "true"
      },
      {
        "name": "features.mart.connect.enabled",
        "value": "true"
      }
    ]
  },
  "analyticsRegion": "us-west1",
  "runtimeType": "CLOUD",
  "subscriptionType": "PAID",
  "caCertificate": "YOUR_CERTIFICATE",
  "authorizedNetwork": "my-network",
  "projectId": "my-cloud-project"
}

    Residência dos dados

      {
    "name": "my-cloud-project",
    "createdAt": "1681412783749",
    "lastModifiedAt": "1681412783749",
    "environments": [
      "test-env"
    ],
    "properties": {
      "property": [
        {
          "name": "features.mart.connect.enabled",
          "value": "true"
        },
        {
          "name": "features.hybrid.enabled",
          "value": "true"
        }
      ]
    },
    "authorizedNetwork": "default",
    "runtimeType": "CLOUD",
    "subscriptionType": "PAID",
    "caCertificate": "YOUR_CERTIFICATE",
    "runtimeDatabaseEncryptionKeyName": "projects/my-cloud-project/locations/us/keyRings/my-key-ring/cryptoKeys/my-key-name",
    "projectId": "my-cloud-project",
    "state": "ACTIVE",
    "billingType": "PAYG",
    "addonsConfig": {
      "advancedApiOpsConfig": {},
      "integrationConfig": {},
      "monetizationConfig": {},
      "connectorsPlatformConfig": {}
    },
    "apiConsumerDataEncryptionKeyName": "projects/my-cloud-project/locations/us-central1/keyRings/my-key-ring/cryptoKeys/my-key-name",
    "controlPlaneEncryptionKeyName": "projects/my-cloud-project/locations/us/keyRings/my-key-ring/cryptoKeys/my-key-name",
    "apiConsumerDataLocation": "us-central1",
    "apigeeProjectId": "i0c2a37e80f9850ab-tp"
  }

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

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

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:

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

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

    3. 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.
    • 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.
  3. Crie uma chave de criptografia de disco:
    1. 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.

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

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

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

  4. Reserve um intervalo de IP para esse recurso que será usado na criação da instância da Apigee.
  5. 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.

  6. 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 7: criar um ambiente

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

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

  3. 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"
]
  4. 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"
    }
  ]
}
  5. 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"'"]
  }'
  6. 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"
  7. 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"'"
  }'
  8. 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 8: 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 peering de VPC

Permita apenas o acesso interno aos proxies da API.

Você precisa criar uma nova VM dentro da rede e conectar-se a ela. Na nova VM, é possível enviar uma solicitação a um proxy de API da Apigee.
Externo com MIG

Permita o acesso externo aos proxies de API.

Use um grupo de instâncias gerenciadas (MIG, na sigla em inglês) para enviar tráfego de API de um serviço de back-end do balanceador de carga global para a Apigee. Com essa configuração, a Apigee só pode se conectar à VPC com peering. Essa configuração permite enviar solicitações de proxy da API Apigee de qualquer máquina ativada para rede.

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 (VPC)

Para encaminhar o tráfego de clientes internos para a Apigee, escolha usar o encerramento do TLS ou não:

  • Opções de TLS: você tem duas opções se quiser fazer chamadas de proxy de API de clientes internos com o TLS ativado:
  • Opção não TLS: se você não precisar ativar o término de TLS, poderá chamar proxies de API em que o cliente desativar a TLS. Por exemplo, usando a opção -k com cURL, é possível desativar o TLS. Consulte Como chamar um proxy de API com acesso somente interno.

Roteamento externo (MIG)

Nesta seção, descrevemos como configurar o roteamento para permitir o acesso externo a proxies de API usando um grupo gerenciado de instâncias (MIG, na sigla em inglês) para enviar o tráfego de API de um serviço de back-end de balanceador de carga global para a Apigee. É necessário fazer isso para enviar uma solicitação de um cliente externo à instância de ambiente de execução da Apigee.

Veja a seguir o processo geral:

Etapa 8a: ativar o Acesso privado do Google para uma sub-rede de sua rede VPC
Etapa 8b: configurar variáveis de ambiente
Etapa 8c: criar um grupo gerenciado de instâncias
Etapa 8d: criar um certificado SSL e uma chave para o balanceador de carga
Etapa 8e: criar um balanceador de carga global
Etapa 8f: conseguir um endereço IP reservado e criar regras de firewall

Cada uma dessas etapas é descrita nas seções a seguir.

Etapa 8a: ativar o Acesso privado do Google para uma sub-rede de sua rede VPC

Para ativar o Acesso privado do Google para uma sub-rede de sua rede VPC, siga os passos indicados em Como ativar o Acesso privado do Google.

Etapa 8b: 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. Recomendamos que você defina essas variáveis antes de continuar:

MIG_NAME=apigee-mig-MIG_NAME   # You can choose a different name if you like
VPC_NAME=default       # If you are using a shared VPC, use the shared VPC name
VPC_SUBNET=default     # Private Google Access must be enabled for this subnet
REGION=RUNTIME_REGION        # The same region as your Apigee runtime instance
APIGEE_ENDPOINT=APIGEE_INSTANCE_IP     # See the tip below for details on getting this IP address value

Você usará essas variáveis várias vezes durante os processos restantes. Se você quiser configurar várias regiões, crie variáveis com valores específicos para cada região.

Etapa 8c: criar um grupo gerenciado de instâncias

Nesta etapa, você cria e configura um grupo gerenciado de instâncias (MIG, na sigla em inglês). Em uma etapa posterior, você adicionará o MIG a um serviço de back-end conectado a um balanceador de carga global. Um MIG é necessário para enviar o tráfego da API do serviço de back-end do balanceador de carga global para a Apigee.

Para criar um MIG:

  1. Crie um modelo de instância executando o seguinte comando: 
    gcloud compute instance-templates create $MIG_NAME \
--project $PROJECT_ID \
--region $REGION \
--network $VPC_NAME \
--subnet $VPC_SUBNET \
--tags=https-server,apigee-mig-proxy,gke-apigee-proxy \
--machine-type e2-medium --image-family debian-10 \
--image-project debian-cloud --boot-disk-size 20GB \
--no-address \
--metadata ENDPOINT=$APIGEE_ENDPOINT,startup-script-url=gs://apigee-5g-saas/apigee-envoy-proxy-release/latest/conf/startup-script.sh

    Como você vê neste comando, as máquinas são do tipo e2-medium. Elas executam o Debian 10 e têm 20 GB de disco. O script startup-script.sh configura o MIG para rotear o tráfego de entrada do balanceador de carga para a instância da Apigee.

  2. Crie um grupo gerenciado de instâncias executando o seguinte comando: 
    gcloud compute instance-groups managed create $MIG_NAME \
--project $PROJECT_ID --base-instance-name apigee-mig \
--size 2 --template $MIG_NAME --region $REGION
  3. Configure o escalonamento automático do grupo executando o seguinte comando: 
    gcloud compute instance-groups managed set-autoscaling $MIG_NAME \
--project $PROJECT_ID --region $REGION --max-num-replicas 3 \
--target-cpu-utilization 0.75 --cool-down-period 90
  4. Defina uma porta nomeada executando o seguinte comando: 
    gcloud compute instance-groups managed set-named-ports $MIG_NAME \
--project $PROJECT_ID --region $REGION --named-ports https:443

Etapa 8d: criar um certificado SSL e uma chave para o balanceador de carga

Você só precisa criar as credenciais uma vez, esteja instalando em uma ou várias regiões. Em um futuro passo, você vai associar essas credenciais ao proxy HTTPS de destino do balanceador de carga.

É possível criar as credenciais com:

Saiba mais sobre como criar e usar certificados SSL com o balanceador de carga do Google Cloud em Certificados SSL e Visão geral dos certificados SSL.

No exemplo a seguir, criamos um certificado SSL gerenciado pelo Google:

  1. Crie estas variáveis de ambiente: 
    CERTIFICATE_NAME=YOUR_CERT_NAME
DOMAIN_HOSTNAME=YOUR_DOMAIN_HOSTNAME

    Defina DOMAIN_HOSTNAME como um nome de host de domínio válido que você registrou. Em uma etapa futura, você vai receber o endereço IP do balanceador de carga e atualizar o registro A para apontar para esse endereço. Por exemplo, um nome de host de domínio pode ter esta aparência: foo.example.com.

  2. Execute o comando gcloud compute ssl-certificates create: 
    gcloud compute ssl-certificates create $CERTIFICATE_NAME \
  --domains=$DOMAIN_HOSTNAME \
  --project $PROJECT_ID \
  --global

    O provisionamento do certificado pode levar até uma hora. Para ver o status do provisionamento, execute este comando:

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

Etapa 8e: criar um balanceador de carga global

  1. Crie uma verificação de integridade: 
    gcloud compute health-checks create https HEALTH_CHECK_NAME \
--project $PROJECT_ID --port 443 --global \
--request-path /healthz/ingress

    Use essa verificação de integridade para garantir a execução do serviço de back-end. Para configurar verificações de integridade mais avançadas em relação a um proxy específico, consulte Como executar verificações de integridade.

  2. Crie um serviço de back-end: 
    gcloud compute backend-services create PROXY_BACKEND_NAME \
--project $PROJECT_ID \
--protocol HTTPS \
--health-checks HEALTH_CHECK_NAME \
--port-name https \
--timeout 302s \
--connection-draining-timeout 300s \
--global
  3. Adicione o MIG ao serviço de back-end com o seguinte comando: 
    gcloud compute backend-services add-backend PROXY_BACKEND_NAME \
--project $PROJECT_ID --instance-group $MIG_NAME \
--instance-group-region $REGION \
--balancing-mode UTILIZATION --max-utilization 0.8 --global
  4. Crie um mapa de URL de balanceamento de carga com o seguinte comando: 
    gcloud compute url-maps create MIG_PROXY_MAP_NAME \
--project $PROJECT_ID --default-service PROXY_BACKEND_NAME
  5. Crie um proxy HTTPS de destino de balanceamento de carga com o seguinte comando: 
    gcloud compute target-https-proxies create MIG_HTTPS_PROXY_NAME \
--project $PROJECT_ID --url-map MIG_PROXY_MAP_NAME \
--ssl-certificates $CERTIFICATE_NAME

Etapa 8f: conseguir um endereço IP reservado e criar regras de firewall

Atribua um endereço IP ao balanceador de carga e crie regras que permitam que o balanceador de carga acesse o MIG. Essa etapa só precisa ser feita uma vez, seja na instalação em uma ou várias regiões.

  1. Reserve um endereço IP para o balanceador de carga: 
    gcloud compute addresses create ADDRESSES_NAME \
--project $PROJECT_ID \
--ip-version=IPV4 \
--global
  2. Crie uma regra de encaminhamento global com o seguinte comando: 
    gcloud compute forwarding-rules create FORWARDING_RULE_NAME \
--project $PROJECT_ID --address ADDRESSES_NAME --global \
--target-https-proxy MIG_HTTPS_PROXY_NAME --ports 443
  3. Consiga um endereço IP reservado executando o seguinte comando: 
    gcloud compute addresses describe ADDRESSES_NAME \
--project $PROJECT_ID --format="get(address)" --global
  4. Etapa importante: acesse o site, o host DNS ou o ISP em que seus registros DNS são gerenciados e verifique se o registro DNS de seu domínio está resolvido para o endereço IP do balanceador de carga do Google Cloud. Esse endereço é o valor do IP retornado na última etapa. Saiba mais em Atualizar os registros DNS A e AAAA para apontar para o endereço IP do balanceador de carga.
  5. Crie uma regra de firewall que permita que o balanceador de carga acesse o MIG usando o comando a seguir: 
    gcloud compute firewall-rules create FIREWALL_RULE_NAME \
--description "Allow incoming from GLB on TCP port 443 to Apigee Proxy" \
--project $PROJECT_ID --network $VPC_NAME --allow=tcp:443 \
--source-ranges=130.211.0.0/22,35.191.0.0/16 --target-tags=gke-apigee-proxy

    Os intervalos de endereços IP 130.211.0.0/22 e 35.191.0.0/16 são os intervalos de endereços IP de origem do Google Load Balancing. Essa regra de firewall permite que o Google Cloud Load Balancing faça solicitações de verificação de integridade ao MIG.

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

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

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

  1. 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/bfac74a67a320c43a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw1"
    }
  ]
}
  2. 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.
  3. Para testar a configuração, acesse Como chamar um proxy de API com acesso somente interno.

Balanceador de carga interno regional

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.

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)

  1. 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"
  }
]
}

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

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

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

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

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

    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.

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

  6. 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.
  7. 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.
  8. 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.

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.

  1. Verifique se você definiu as variáveis de ambiente neste link.
  2. 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"
    }
  ]
}

  3. 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.
    • $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.
  4. 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
  5. 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

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

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

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

  8. 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.
  9. 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.

  1. Verifique se você definiu as variáveis em Definir variáveis de ambiente.
  2. Crie uma sub-rede somente proxy: 
    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.
  3. 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"
    }
  ]
}
  4. 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
  5. 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

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

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

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

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

    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.
  9. 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
  10. 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 9: implantar um proxy de amostra

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

  3. 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"
  4. 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"

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