Aprovisione uma organização paga com intercâmbio da VPC

Aprovisione uma organização paga com intercâmbio da VPC

Esta página aplica-se ao Apigee, mas não ao Apigee Hybrid.

Veja a documentação do Apigee Edge.

Este documento descreve como instalar e configurar o Apigee a partir da linha de comandos com a interligação de VPCs. Estes passos aplicam-se aos modelos de preços de subscrição e de pagamento conforme o uso para organizações pagas com ou sem a residência de dados ativada.

Resumo dos passos

Os passos de aprovisionamento são os seguintes:

Passo 1: defina variáveis de ambiente

Configure o gcloud e defina variáveis de ambiente para utilização em passos posteriores:

  1. Certifique-se de que concluiu os requisitos de configuração indicados em Antes de começar.
  2. Tem de ter o Cloud SDK instalado. Se precisar de o instalar, consulte o artigo Instalar o SDK do Google Cloud.
  3. Inicialize o SDK do Google Cloud, conforme descrito em Inicializar a CLI gcloud, ou certifique-se de que o projeto do Google Cloud que criou em Pré-requisitos é o projeto predefinido para gcloud.
  4. Defina as seguintes variáveis de ambiente no terminal de comandos. Selecione o separador que corresponde ao tipo de organização de que 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"

    Onde:

    • AUTH define o cabeçalho Authentication com um token de portador. Vai usar este cabeçalho quando chamar as APIs Apigee. Tenha em atenção que o token expira após um período e, quando isso acontece, pode regenerá-lo facilmente através do mesmo comando. Para mais informações, consulte a página de referência do comando print-access-token.
    • PROJECT_ID é o ID do projeto do Google Cloud que criou como parte dos Pré-requisitos.
    • PROJECT_NUMBER é o número do projeto do Google Cloud que criou como parte dos Pré-requisitos.
    • RUNTIME_LOCATION é a localização física onde a instância do Apigee que vai criar mais tarde se encontra. Para ver uma lista de localizações de tempo de execução disponíveis, consulte o artigo Localizações do Apigee.

    • ANALYTICS_REGION é a localização física na qual os dados de estatísticas do Apigee serão armazenados. Para ver uma lista das regiões da API Apigee Analytics disponíveis, consulte o artigo Localizações da Apigee.

      RUNTIME_LOCATION e ANALYTICS_REGION podem ser a mesma região, mas não têm de ser.

    • BILLING_TYPE é o tipo de faturação da organização que criar. 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"

    Onde:

    • AUTH define o cabeçalho Authentication com um token de portador. Vai usar este cabeçalho quando chamar as APIs Apigee. Tenha em atenção que o token expira após um período e, quando isso acontece, pode regenerá-lo facilmente através do mesmo comando. Para mais informações, consulte a página de referência do comando print-access-token.
    • PROJECT_ID é o ID do projeto do Google Cloud que criou como parte dos Pré-requisitos.
    • PROJECT_NUMBER é o número do projeto do Google Cloud que criou como parte dos Pré-requisitos.
    • RUNTIME_LOCATION é a localização física onde a instância do Apigee que vai criar mais tarde se encontra. Para ver uma lista de localizações de tempo de execução disponíveis, consulte o artigo Localizações do Apigee.

      A localização do tempo de execução tem de estar dentro da localização do plano de controlo.
    • CONTROL_PLANE_LOCATION é a localização física na qual os dados do plano de controlo do Apigee são armazenados. Para ver uma lista de localizações do plano de controlo disponíveis, consulte o artigo Localizações do Apigee.
    • CONSUMER_DATA_REGION é uma sub-região da região do plano de controlo. Tem de especificar a CONTROL_PLANE_LOCATION e a CONSUMER_DATA_REGION. Para ver uma lista das regiões de dados de consumidores disponíveis, consulte as localizações do Apigee.
    • BILLING_TYPE é o tipo de faturação da organização que criar. Os valores válidos são:

  5. (Opcional) Verifique o seu trabalho repetindo os valores que acabou de definir. Tenha em atenção que, quando quiser usar uma variável nos seus comandos, preceda o nome da variável com um cifrão ($).

    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 seus comandos echo devem ter um aspeto semelhante ao seguinte:

     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 seus comandos echo devem ter um aspeto semelhante ao seguinte:

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

Passo 2: ative as APIs

  1. O Apigee requer que ative várias APIs Google Cloud. Ative-as executando o seguinte comando services enable:

     gcloud services enable apigee.googleapis.com \     servicenetworking.googleapis.com \     apihub.googleapis.com \     compute.googleapis.com \     cloudkms.googleapis.com --project=$PROJECT_ID
  2. (Opcional) Para verificar o 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 acabou de ativar.

Passo 3: crie a identidade do serviço Apigee

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

    gcloud beta services identity create --service=apigee.googleapis.com \   --project=$PROJECT_ID
  2. Verifique se o agente foi criado com êxito. A resposta deve apresentar o nome do agente no seguinte formato: service-PROJECT_NUMBER@gcp-sa-apigee.iam.gserviceaccount.com. por exemplo:

    Service identity created: [email protected]

Passo 4: configure a rede de serviços

Neste passo, atribui um par de intervalos de endereços IP (um intervalo CIDR /22 e /28) ao Apigee e faz o peering de VPC entre a sua rede e a rede do Apigee. Cada instância do Apigee requer um intervalo CIDR não sobreposto de /22 e /28. Ao plano de tempo de execução do Apigee são atribuídos endereços IP dentro deste intervalo CIDR. Como resultado, é importante que o intervalo esteja reservado para o Apigee e não seja usado por outras aplicações na sua rede VPC. Para mais informações e considerações importantes, consulte o artigo Compreender os intervalos de peering.

Tenha em atenção que está a criar um intervalo de IPs de rede suficiente para uma instância do Apigee. Se planear criar instâncias adicionais do Apigee, tem de repetir este passo para cada uma delas. Não é possível partilhar os intervalos entre instâncias. Consulte também o artigo Expansão do Apigee para várias regiões.

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

    Onde:

    • RANGE_NAME é o nome do intervalo de endereços IP que está a criar. Pode atribuir o nome que quiser ao intervalo. Por exemplo: google-svcs
    • NETWORK_NAME é o nome do recurso de rede no qual os endereços devem ser reservados.

      A Google cria uma rede predefinida (denominada default) para cada novo projeto, para que a possa usar. No entanto, a Google não recomenda a utilização da rede predefinida para fins que não sejam testes.

  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

    Onde --addresses lhe permite especificar opcionalmente um intervalo de moradas. Por exemplo, para atribuir o bloco CIDR 192.168.0.0/22, especifique 192.168.0.0 para o endereço e 22 para o comprimento do prefixo. Consulte também Criar uma atribuição de IP.

    Se não fornecer o parâmetro --addresses, o gcloud seleciona um intervalo de endereços disponível para si.

    Em caso de êxito, o gcloud responde com o seguinte:

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

    Depois de criar um intervalo de endereços IP, os endereços são associados ao projeto até os libertar.

  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. Este intervalo é obrigatório e é usado pelo Apigee para fins de resolução de problemas, e não pode ser personalizado nem 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

    Onde --addresses lhe permite especificar opcionalmente um intervalo de moradas. Por exemplo, para atribuir o bloco CIDR 192.168.0.0/28, especifique 192.168.0.0 para o endereço e 28 para o comprimento do prefixo. Consulte também Criar uma atribuição de IP.

    Se não fornecer o parâmetro --addresses, o gcloud seleciona um intervalo de endereços disponível para si.

  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. Associe os seus serviços à rede através do 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

    Esta operação pode demorar alguns minutos a ser concluída. Em caso de êxito, gcloud responde com o seguinte, em que OPERATION_ID é o UUID da LRO.

    Operation "operations/OPERATION_ID" finished successfully.
  7. O Apigee cria uma ligação entre a sua rede e os serviços da Google; especificamente, o Apigee liga o seu projeto à API Service Networking através do intercâmbio de VPC. O Apigee também associa endereços IP ao seu projeto.

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

Passo 5: crie uma organização

Antes de poder criar uma organização, tem de criar um conjunto de chaves e uma chave de encriptação da base de dados de tempo de execução (consulte o passo 1) e, se estiver a usar a residência de dados, conjuntos de chaves e chaves de encriptação do plano de controlo (consulte o passo 2). Estas chaves do Cloud KMS encriptam os dados armazenados e replicados nas localizações de tempo de execução e do plano de controlo. O Apigee usa estas entidades para encriptar dados de aplicações, como KVMs, cache e segredos de clientes, que são armazenados na base de dados. Para mais informações, consulte o artigo Acerca das chaves de encriptação do Apigee.

  1. Crie um conjunto de chaves e uma chave de encriptação de base de dados de tempo de execução.

    1. Defina uma variável de ambiente para a localização do anel de encriptação e da chave da base de dados de tempo de execução. Isto ajuda a garantir a consistência quando os cria e facilita o acompanhamento na documentação.

      O valor é a localização física onde o conjunto de chaves de encriptação da base de dados de tempo de execução e a chave são armazenados.

      Região única

      Configurações de região única (nas quais tem apenas uma instância numa região): escolha entre as localizações regionais do KMS suportadas.

      Por exemplo:

      RUNTIMEDBKEY_LOCATION="us-west1"

      O valor pode ser o mesmo que o seu $RUNTIME_LOCATION (também uma região), mas não tem de o ser. No entanto, pode haver uma vantagem em termos de desempenho se forem iguais.

      Multirregião

      Configurações multirregionais: escolha entre as localizações multirregionais suportadas (como us ou europe) ou localizações birregionais.

      Por exemplo:

      RUNTIMEDBKEY_LOCATION="us"

      Recomendamos que, se tiver uma configuração multirregional nos EUA, use us para a sua localização, se possível. Caso contrário, use nam4.

    2. Defina variáveis de ambiente para os conjuntos de chaves e os nomes das chaves da base de dados.

      O nome do conjunto de chaves tem de ser exclusivo da sua organização. Se criar uma segunda ou uma região subsequente, o nome não pode ser igual ao de outros nomes de conjuntos de chaves.

      RUNTIMEDB_KEY_RING_NAME=YOUR_DB_KEY_RING_NAME RUNTIMEDB_KEY_NAME=YOUR_DB_KEY_NAME
    3. (Opcional) Verifique o seu trabalho repetindo os valores que acabou de definir. Lembre-se de que, quando quiser usar uma variável nos seus comandos, deve preceder o nome da variável com um cifrão ($).
      echo $RUNTIMEDBKEY_LOCATION echo $RUNTIMEDB_KEY_RING_NAME echo $RUNTIMEDB_KEY_NAME
    4. Crie um novo conjunto de chaves:
       gcloud kms keyrings create $RUNTIMEDB_KEY_RING_NAME \   --location $RUNTIMEDBKEY_LOCATION --project $PROJECT_ID

      A localização da chave de encriptação da base de dados de tempo de execução do Apigee é compatível com todas as localizações do Cloud KMS que suportam 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

      Este comando cria a chave e adiciona-a ao conjunto de chaves.

      Obtenha 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 ficheiro):

       projects/PROJECT_ID/locations/RUNTIMEDBKEY_LOCATION/keyRings/RUNTIMEDB_KEY_RING_NAME/cryptoKeys/RUNTIMEDB_KEY_NAME
    6. Coloque o ID da chave numa variável de ambiente. Vai usar esta variável num comando posterior:

      RUNTIMEDB_KEY_ID=YOUR_RUNTIMEDB_KEY_ID
    7. Conceda acesso ao agente do serviço 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

      Este comando associa a chave ao agente do serviço Apigee.

      Após a conclusão bem-sucedida deste pedido, o gcloud responde com algo semelhante ao seguinte:

       Updated IAM policy for key [runtime]. bindings: - members:   - serviceAccount:[email protected]   role: roles/cloudkms.cryptoKeyEncrypterDecrypter etag: BwWqgEuCuwk= version: 1

      Se receber um erro como o seguinte:

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

      Certifique-se de que usou o número do projeto e não o nome do projeto no endereço de email da conta de serviço.

  2. Se estiver a usar a residência de dados, crie um conjunto de chaves de encriptação do plano de controlo e uma chave. Se não estiver a usar a residência de dados, avance para o passo 3.
  3. Execute os passos seguintes para criar um conjunto de chaves e uma chave de encriptação do plano de controlo.

    1. Defina uma variável de ambiente para a localização do anel e da chave de encriptação da base de dados do plano de controlo:
      CONTROL_PLANE_LOCATION=YOUR_CONTROL_PLANE_LOCATION CONSUMER_DATA_REGION=YOUR_CONSUMER_DATA_REGION

      Onde:

      • CONTROL_PLANE_LOCATION é a localização física na qual os dados do plano de controlo do Apigee são armazenados. Para ver uma lista de localizações do plano de controlo disponíveis, consulte o artigo Localizações do Apigee.
      • CONSUMER_DATA_REGION é uma sub-região da região do plano de controlo. Tem de especificar a CONTROL_PLANE_LOCATION e a CONSUMER_DATA_REGION. Para ver uma lista das regiões de dados de consumidores disponíveis, consulte as localizações do Apigee.
    2. Defina variáveis de ambiente para os conjuntos de chaves e os nomes das chaves da base de dados do plano de controlo.

      O nome do conjunto de chaves tem de ser exclusivo da 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

      Onde:

      • CONTROL_PLANE_KEY_RING_NAME é o nome do conjunto de chaves que vai usar para identificar o seu conjunto de chaves de encriptação do plano de controlo.
      • CONTROL_PLANE_KEY_NAME é o nome da chave que vai usar para identificar a sua chave de encriptação do plano de controlo.
      • CONSUMER_DATA_KEY_RING_NAME é o nome do conjunto de chaves que vai usar para identificar o seu conjunto de chaves de encriptação da região de dados do consumidor.
      • CONSUMER_DATA_KEY_NAME é o nome da chave que vai usar para identificar a chave de encriptação da sua região de dados do consumidor.
    3. Crie um novo conjunto de chaves:
       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

      Este comando cria a chave e adiciona-a ao conjunto de chaves.

      Obtenha 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 ficheiro):

      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 numa variável de ambiente. Vai usar esta variável num comando posterior:
       CONTROL_PLANE_KEY_ID=YOUR_CONTROL_PLANE_KEY_ID 
       CONSUMER_DATA_KEY_ID=YOUR_CONSUMER_DATA_KEY_ID
    6. Conceda acesso ao agente do serviço 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 

      Este comando associa a chave ao agente do serviço Apigee. Após a conclusão bem-sucedida deste pedido, 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 receber um erro como o seguinte:

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

      Certifique-se de que usou o número do projeto e não o nome do projeto no endereço de email da conta de serviço.

    Veja também: Resolução de problemas de CMEK.

  4. Crie a organização enviando o seguinte pedido à API organizations do 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"'"   }'

    Onde:

    • -d define o payload de dados para o pedido. Este payload tem de incluir o seguinte:
      • name: identifica a sua nova organização. Tem de ser o mesmo nome que o ID do projeto.

      • analyticsRegion: especifica a localização física onde os seus dados de estatísticas serão armazenados.

      • runtimeType: defina este valor como CLOUD.
      • billingType: especifica o tipo de faturação da organização criada.
      • authorizedNetwork: identifica a rede de peering que especificou em Configurar redes de serviços.
      • runtimeDatabaseEncryptionKeyName: O ID da chave de encriptação da aplicação que criou no passo anterior. Lembre-se de que o ID está estruturado como um caminho de ficheiro. Por exemplo:
        projects/my-project/locations/us-west1/keyRings/my-key-ring/cryptoKeys/my-key

    Residência dos dados

    Crie uma organização através da 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"'"   }'

    Onde:

    -d define o payload de dados para o pedido. Este payload tem de incluir o seguinte:

    • name: identifica a sua nova organização. Tem de ser o mesmo nome que o ID do projeto.
    • runtimeType: defina este valor como CLOUD.
    • billingType: especifica o tipo de faturação da organização criada.
    • controlPlaneEncryptionKeyName: é o ID da chave do plano de controlo.
    • apiConsumerDataLocation: também tem de especificar uma sub-região para utilização por recursos internos. Consulte as Regiões de residência dos dados para ver os valores suportados.
    • apiConsumerDataEncryptionKeyName: é o ID da chave da região de dados do consumidor.
    • authorizedNetwork: identifica a rede de peering que especificou em Configurar redes de serviços.
    • runtimeDatabaseEncryptionKeyName: O ID da chave de encriptação da aplicação que criou no passo anterior. Lembre-se de que o ID está estruturado como um caminho de ficheiro. Por exemplo:
      projects/my-project/locations/us-west1/keyRings/my-key-ring/cryptoKeys/my-key

    Depois de executar este comando, o Apigee inicia uma operação de longa duração, que pode demorar alguns minutos a ser concluída.

    Se receber um erro, verifique a utilização de aspas em torno dos valores das variáveis na carga útil de dados. Certifique-se de que tem aspas duplas-simples-duplas à volta da variável $PROJECT_ID, como mostra o exemplo seguinte:

    "'"$PROJECT_ID"'"

    Se usar strings simples (não variáveis de ambiente) para valores de pedidos, pode envolvê-las em aspas duplas na string de payload entre aspas simples, como mostra o exemplo seguinte:

    '{ "name":"my-gcp-project", ... }'
  5. Aguarde alguns minutos.
  6. Para verificar o estado do seu pedido de criação, pode enviar um pedido GET para a API List organizations do Apigee, conforme mostra o exemplo seguinte:

    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 vir esta resposta, significa que 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 o Apigee tiver criado com êxito uma nova organização, recebe uma resposta semelhante à seguinte:

    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 o Apigee devolver uma resposta de erro HTTP, consulte o artigo Criar uma organização do Apigee.

Passo 6: crie uma instância de tempo de execução

Uma instância de tempo de execução é onde o seu projeto do Apigee e os serviços relacionados são armazenados. Esta fornece o ponto final virado para o utilizador dos seus serviços. Para criar uma nova instância de tempo de execução:

  1. Verifique se o Apigee concluiu a criação da sua organização. Enviou um pedido para criar uma nova organização em Criar uma organização do Apigee, mas tem de se certificar de que o processo está concluído antes de continuar.

    Para o fazer, envie o seguinte pedido para a 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 tiver as autorizações adequadas para a ver), o Apigee responde com detalhes sobre a mesma. Se o Apigee responder com um erro, aguarde alguns minutos e envie o pedido novamente.

  2. Semelhante à tarefa anterior, em que criou uma chave de encriptação para a base de dados, agora tem de criar uma chave do Cloud KMS usada para encriptar dados no 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. Onde:

  • INSTANCE_NAME: o nome da nova instância. Por exemplo, my-runtime-instance. O nome tem de começar por uma letra minúscula, pode ter até 32 carateres e só pode incluir letras minúsculas, números e hífenes. Não pode começar nem terminar com um hífen e tem de ter, pelo menos, dois carateres.
  • RUNTIME_LOCATION é o local físico onde o cluster está alojado. Os valores válidos são qualquer localização permitida pelo Compute Engine. (Consulte as regiões e zonas disponíveis.) Este exemplo usa us-west1.
  • DISK_KEY_RING_NAME é o nome do conjunto de chaves de encriptação de disco.
  • DISK_KEY_NAME é o nome da chave de encriptação de disco.
  • Crie uma chave de encriptação de disco:
    1. Crie um novo conjunto de chaves de disco:
       gcloud kms keyrings create $DISK_KEY_RING_NAME \   --location $RUNTIME_LOCATION \   --project $PROJECT_ID

      O porta-chaves de disco tem de estar definido para a mesma localização que a instância. Cada instância e anel de chaves deve ter a sua própria localização.

    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 respetivo caminho da chave. Pode obter o caminho da chave com o seguinte comando:

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

      O caminho principal tem um aspeto semelhante ao seguinte:

      projects/PROJECT_ID/locations/RUNTIME_LOCATION/keyRings/my-disk-key-ring/cryptoKeys/my-disk-key
    3. Coloque o caminho da chave numa variável de ambiente. Vai usar esta variável num comando posterior:

      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 do serviço 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

      Este comando associa a chave ao agente do serviço Apigee.

    Para mais informações, consulte o artigo Acerca das chaves de encriptação do Apigee.

  • Crie uma nova instância de tempo de execução para o seu projeto enviando um pedido POST para a API Instances do 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"'"]   }'

    Onde:

    Embora o intervalo de IP /22 seja usado para executar cargas de trabalho principais do Apigee, o intervalo /28 é usado pelo Apigee para aceder à instância para fins de resolução de problemas. Consulte também Criar instâncias.

    Este pedido pode demorar até 20 minutos a ser concluído porque o Apigee tem de criar e iniciar um novo cluster do Kubernetes, instalar os recursos do Apigee nesse cluster e configurar o equilíbrio de carga.

    Se o Apigee devolver um erro, consulte o artigo Criar uma nova instância.

  • Para verificar o estado do seu pedido de criação de instância de tempo de execução, execute o seguinte comando. Quando o estado for ATIVO, pode avançar para o passo seguinte.

    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"
  • Passo 7: crie um ambiente

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

    1. Defina as variáveis de ambiente a usar nesta secção. As variáveis de ambiente específicas que criar dependem de estar a criar um ambiente para uma organização de subscrição ou de pagamento conforme o uso.

      Subscrição

      Para um ambiente de subscrição, crie estas variáveis:

      ENVIRONMENT_NAME="YOUR_ENV_NAME" ENV_GROUP_NAME="YOUR_ENV_GROUP_NAME" ENV_GROUP_HOSTNAME="YOUR_ENV_GROUP_HOSTNAME"

      Onde:

      • 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 anfitrião de domínio válido. Por exemplo: foo.example.com

      Pay-as-you-go

      Para um ambiente de pagamento conforme o uso, 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"

      Onde:

      • ENVIRONMENT_NAME é um nome de string. Por exemplo: test
      • ENVIRONMENT_TYPE é o tipo de ambiente para este ambiente e só é aplicável a utilizadores de Pay-as-you-go, que têm de especificar um destes valores: BASE, INTERMEDIATE ou COMPREHENSIVE. Os outros utilizadores devem omitir o tipo de ambiente.
      • ENV_GROUP_NAME é um nome de string. Por exemplo: test-group
      • ENV_GROUP_HOSTNAME é um nome de anfitrião de domínio válido. Por exemplo: foo.example.com
    2. Crie um novo ambiente com a API Environments. Os comandos específicos que usa dependem de estar a criar um ambiente para uma organização de subscrição ou de pagamento conforme o uso.

      Subscrição

      Para um novo ambiente de subscriçã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"'"   }'

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

      O Apigee cria um novo ambiente.

      Pay-as-you-go

      Para um novo ambiente de pagamento conforme o uso, 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"'"   }'

      O Apigee cria um novo ambiente.

    3. Antes de continuar, verifique se o Apigee terminou de criar o 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"

      O Apigee responde com uma lista de ambientes disponíveis. Por exemplo, se o nome do seu ambiente for test, o Apigee responde com o seguinte:

      [   "test" ]
    4. Associe o novo ambiente à instância do tempo 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"'"     }'

      Esta operação pode demorar alguns minutos a ser concluída. Para verificar se o anexo foi concluído, 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"

      Quando vir um resultado como o seguinte, pode avançar para o passo seguinte:

      {   "attachments": [     {       "name": "ed628782-c893-4095-b71c-f4731805290a",       "environment": "test",       "createdAt": "1641604447542"     }   ] }
    5. Crie um novo grupo de ambientes com o seguinte comando. Para mais informações, consulte o artigo Acerca dos ambientes e dos 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 pela conclusão da operação. Pode verificar o estado do seu novo grupo através de um pedido como o seguinte:

      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. Associe o novo ambiente ao novo grupo de ambientes 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 verificar o estado 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"

    Passo 8: configure o encaminhamento

    Neste passo, configura a forma como as aplicações cliente comunicam com o Apigee. O tráfego do cliente para o Apigee também é denominado tráfego "northbound". As opções de configuração de saída incluem o seguinte. Aceda à opção de configuração que quer usar e siga os passos dessa opção:

    Tipo de acesso Descrição do processo de configuração e implementação
    Interno com intercâmbio da VPC

    Permita apenas o acesso interno aos seus proxies de API.

    Tem de criar uma nova VM na rede e estabelecer ligação à mesma. A partir da nova VM, pode enviar um pedido a um proxy de API do Apigee.

    External with MIG

    Permita o acesso externo aos seus proxies de API.

    Use um grupo de instâncias geridas (GIG) para enviar tráfego de API do serviço de back-end de um balanceador de carga global para o Apigee. Com esta configuração, o Apigee só consegue ligar-se à VPC com peering. Esta configuração permite-lhe enviar pedidos de proxy de API do Apigee a partir de qualquer máquina com ligação à rede.

    Interno com PSC (novo)

    Permita apenas o acesso interno aos seus proxies de API a partir de qualquer um dos seus projetos do Google Cloud através do Private Service Connect (PSC).

    O PSC permite uma ligação privada entre um produtor de serviços (Apigee) e um consumidor de serviços (o projeto de VPC com intercâmbio e/ou um ou mais outros projetos do Google Cloud que controla). Com este método, os pedidos passam por um ponto final de serviço ou um balanceador de carga interno regional para um único ponto de ligação, denominado anexo de serviço. Esta configuração permite que os seus clientes internos enviem pedidos de proxy de API do Apigee a partir de qualquer máquina com ligação à rede.

    Externo com PSC (novo)

    Permita o acesso externo aos seus proxies de API através do Private Service Connect (PSC).

    Use o Private Service Connect (PSC) para ativar a ligação privada entre um produtor de serviços (Apigee) e um consumidor de serviços (o projeto de VPC com peering e/ou um ou mais projetos do Google Cloud que controla). Com este método, os pedidos passam por um balanceador de carga externo global ou um balanceador de carga externo regional para um único ponto de ligação, denominado ligação de serviço. Esta configuração permite-lhe enviar pedidos de proxy de API do Apigee a partir de qualquer máquina com ligação à rede.

    Cada uma destas abordagens de encaminhamento é apresentada nas instruções abaixo.

    Encaminhamento interno (VPC)

    Para o encaminhamento de tráfego de clientes internos para o Apigee, pode optar por usar a terminação TLS ou não:

    • Opções de TLS: tem duas opções se quiser fazer chamadas de proxy de API a partir de clientes internos com o TLS ativado:
      • (Opção 1) Configure um balanceador de carga interno (ILB):
        1. Crie um grupo de instâncias geridas (MIG) no seu projeto. Para criar o MIG, siga os passos 8a, 8b e 8c no separador Encaminhamento externo (MIG).
        2. Crie e configure um balanceador de carga HTTPS(S) interno (ILB) e anexe o MIG que criou ao serviço de back-end do ILB, conforme explicado no artigo Configure o balanceamento de carga HTTP(S) interno com back-ends de grupos de instâncias de VMs. Com a configuração do ILB, tem controlo total sobre os certificados da AC usados com o ILB.
        3. Aceda a Chamar um proxy de API com acesso apenas interno para testar a configuração.
      • (Opção 2) Use o nome de domínio totalmente qualificado interno predefinido e o IP do balanceador de carga interno da instância do Apigee. Esta situação é recomendada apenas para fins de teste e não para um ambiente de produção. Neste caso, são usados certificados autoassinados criados pelo Apigee, com o equilibrador de carga interno do Apigee, e não os pode alterar. Consulte o artigo Chamar um proxy de API com acesso apenas interno.
    • Opção sem TLS: se não precisar de terminação TLS, a invocação do proxy de API pode ser realizada ignorando a validação do certificado TLS. Por exemplo, a opção -k da ferramenta de linha de comandos curl desativa a validação de certificados. No entanto, o protocolo TLS permanece ativo durante a ligação. Tenha em atenção que o acesso à entrada do Apigee através de HTTP simples na porta 80 não é suportado, de forma semelhante ao Apigee Hybrid. Consulte o artigo Chamar um proxy de API com acesso apenas interno.

    Encaminhamento externo (MIG)

    Esta secção descreve como configurar o encaminhamento para permitir o acesso externo a proxies de API através de um grupo de instâncias gerido (MIG) para enviar tráfego de API do serviço de back-end de um equilibrador de carga global para o Apigee. Tem de o fazer antes de poder enviar um pedido de um cliente externo para a sua instância do runtime do Apigee.

    O processo geral é o seguinte:

    Passo 8a: ative o acesso privado à Google para uma sub-rede da sua rede VPC
    Passo 8b: configure as variáveis de ambiente
    Passo 8c: crie um grupo de instâncias gerido
    Passo 8d: crie um certificado SSL e uma chave para o equilibrador de carga
    Passo 8e: crie um equilibrador de carga global
    Passo 8f: obtenha um endereço IP reservado e crie regras de firewall

    Cada um destes passos é descrito nas secções seguintes.

    Passo 8a: ative o acesso privado à Google para uma sub-rede da sua rede VPC

    Para ativar o acesso privado à Google para uma sub-rede da sua rede VPC, siga os passos indicados em Ativar o acesso privado à Google.

    Passo 8b: configure as variáveis de ambiente

    As instruções nesta secção usam variáveis de ambiente para fazer referência a strings usadas repetidamente. Recomendamos que defina estas opções 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

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

    Passo 8c: crie um grupo de instâncias gerido

    Neste passo, cria e configura um grupo de instâncias geridas (MIG). Num passo posterior, adiciona o MIG a um serviço de back-end associado a um balanceador de carga global. Um MIG é necessário para enviar tráfego de API do serviço de back-end do balanceador de carga global para o 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-12 \ --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 pode ver neste comando, as máquinas são do tipo e2-medium. Executam o Debian 12 e têm 20 GB de disco. O script startup-script.sh configura o MIG para encaminhar o tráfego de entrada do balanceador de carga para a instância do Apigee.

    2. Crie um grupo de instâncias gerido 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 dimensionamento automático para o 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 com nome executando o seguinte comando:
      gcloud compute instance-groups managed set-named-ports $MIG_NAME \ --project $PROJECT_ID --region $REGION --named-ports https:443

    Passo 8d: crie um certificado SSL e uma chave para o equilibrador de carga

    Só tem de criar as credenciais uma vez, quer esteja a fazer a instalação numa única região ou em várias regiões. Num passo posterior, vai associar estas credenciais ao proxy HTTPS de destino do balanceador de carga.

    Pode criar as credenciais com:

    Para mais informações sobre como criar e usar certificados SSL para o balanceador de carga do Google Cloud, consulte os artigos Certificados SSL e Vista geral dos certificados SSL.

    No exemplo seguinte, criamos um certificado SSL gerido pela 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 anfitrião de domínio válido que tenha registado. Num passo posterior, vai obter o endereço IP do equilibrador de carga e atualizar o registo A do domínio para apontar para esse endereço. Por exemplo, o nome do anfitrião de um domínio pode ter o seguinte aspeto: 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 aprovisionamento do certificado pode demorar até uma hora. Para verificar o estado do aprovisionamento, execute este comando:

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

    Passo 8e: crie um balanceador de carga global

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

      Vai usar esta verificação de estado para garantir que o serviço de back-end está em execução. Para configurar verificações de funcionamento mais avançadas num proxy específico, consulte Realizar verificações de funcionamento.

    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 seu 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 URLs 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

    Passo 8f: obtenha um endereço IP reservado e crie regras de firewall

    Tem de atribuir um endereço IP ao balanceador de carga e, em seguida, criar regras que permitam ao balanceador de carga aceder ao MIG. Só tem de fazer este passo uma vez, quer esteja a fazer a instalação numa única região ou em 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. Obtenha o endereço IP reservado executando o seguinte comando:
      gcloud compute addresses describe ADDRESSES_NAME \ --project $PROJECT_ID --format="get(address)" --global
    4. Passo importante: aceda ao site, ao anfitrião de DNS ou ao ISP onde os seus registos de DNS são geridos e certifique-se de que o registo de DNS do seu domínio é resolvido para o endereço IP do balanceador de carga do Google Cloud. Este endereço é o valor de IP devolvido no último passo. Para mais detalhes, consulte o artigo Atualize os registos A e AAAA do DNS para apontarem para o endereço IP do balanceador de carga.
    5. Crie uma regra de firewall que permita ao balanceador de carga aceder ao MIG através do seguinte comando:
      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

      Tenha em atenção que 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 para o Google Load Balancing. Esta regra de firewall permite que o Google Cloud Load Balancing faça pedidos de verificação de funcionamento ao MIG.

    O aprovisionamento do Apigee está concluído. Aceda a Implemente um proxy de exemplo.

    Encaminhamento interno (PSC)

    Esta secção explica como permitir apenas o acesso interno aos seus proxies de API a partir de qualquer um dos seus projetos do Google Cloud através do Private Service Connect (PSC).

    Tem duas opções para configurar o acesso interno com o PSC:

    Selecione o separador abaixo para a sua escolha de configuração e siga os passos:

    Ponto final do serviço

    Crie um ponto final de serviço do PSC para a associação de serviço

    1. Obtenha a associação de serviço da instância que criou 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"

      Na saída de exemplo seguinte, o valor serviceAttachment é apresentado a 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 ponto final de serviço do PSC que aponte para a associação do serviço que obteve do corpo da resposta da instância no passo anterior, conforme explicado em Crie um ponto final do Private Service Connect.
    3. Para testar a configuração, aceda a: Chamar um proxy de API com acesso apenas interno.

    LB regional interno

    Passo 7a: configure as variáveis de ambiente

    As instruções nesta secção usam variáveis de ambiente para fazer referência a strings usadas repetidamente. Certifique-se de que definiu as variáveis em Definir variáveis de ambiente.

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

    NEG_NAME=YOUR_NEG_NAME   NETWORK_NAME=YOUR_NETWORK_NAME   SUBNET_NAME=YOUR_SUBNET_NAME   TARGET_SERVICE=TARGET_SERVICE_ATTACHMENT 

    Onde:

    • NEG_NAME: um nome para o grupo de pontos finais da rede.
    • NETWORK_NAME: (Opcional) Nome da rede na qual o NEG é criado. Se omitir este parâmetro, é usada a rede do projeto default.
    • SUBNET_NAME: nome da sub-rede usada para a conetividade privada ao produtor. O tamanho da sub-rede pode ser pequeno: o NEG do PSC só precisa de um IP da sub-rede. Para o Apigee, só é necessário um NEG do PSC por região. A sub-rede pode ser partilhada e usada por VMs ou outras entidades. Se não for especificada uma sub-rede, os pontos finais de rede podem pertencer a qualquer sub-rede na região onde o grupo de pontos finais de rede é criado.
    • TARGET_SERVICE: a associação de serviço à qual quer estabelecer ligação. Por exemplo: projects/bfac7497a40c32a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw7

    Passo 7b: crie uma sub-rede apenas de 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

    Passo 7c: crie um grupo de pontos finais de rede (NEG)

    1. Obtenha a associação de serviço da instância que criou 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"

      Na saída de exemplo seguinte, o valor serviceAttachment é apresentado a 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 que obteve do corpo da resposta da instância no passo 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 --network=$NETWORK_NAME --subnet=$SUBNET_NAME 

      Onde

      • $PROJECT_ID pode ser o projeto do Google Cloud que já está associado à sua organização do Apigee ou um projeto do Google Cloud incluído no consumerAcceptlist quando a instância de runtime do Apigee foi criada.

    Passo 7d: configure 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_LOCATION \ --project=$PROJECT_ID
    3. Substitua BACKEND_SERVICE_NAME pelo nome do serviço de back-end.

    4. Adicione o NEG ao serviço de back-end:
      gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \ --network-endpoint-group=$NEG_NAME \ --region=$RUNTIME_LOCATION \ --project=$PROJECT_ID

      Substitua o seguinte:

      • NEG_NAME: o nome do grupo de pontos finais da rede.
      • BACKEND_SERVICE_NAME com o nome do serviço de back-end.
    5. Para criar um balanceador de carga HTTPS, tem de ter um recurso de certificado SSL para usar no proxy de destino HTTPS.

      Use este comando para criar um recurso de certificado SSL autogerido. Para criar um certificado SSL autogerido, precisa de um ficheiro de chave privada local e um ficheiro de certificado local. Se precisar de criar estes ficheiros, consulte o passo 1 da utilização de certificados SSL autogeridos.

      gcloud compute ssl-certificates create CERTIFICATE \ --certificate LB_CERT \ --private-key LB_PRIVATE_KEY --region=$RUNTIME_LOCATION --project=$PROJECT_ID

      Substitua o seguinte:

      • CERTIFICATE: um nome para o certificado.
      • LB_CERT: o caminho para o ficheiro de certificado no formato PEM do seu certificado autogerido.
      • LB_PRIVATE_KEY: o caminho para o ficheiro de chave privada no formato PEM do seu certificado autogerido.
    6. Crie um mapa de URLs para o balanceador de carga.

      Um mapa de URLs tem de fazer referência a um serviço de back-end predefinido. Defina o serviço de back-end que acabou de criar como predefinição.

      gcloud compute url-maps create URL_MAP_NAME \ --default-service=DEFAULT_BACKEND_SERVICE_NAME \ --region=$RUNTIME_REGION \ --project=$PROJECT_ID

      Substitua o seguinte:

      • URL_MAP_NAME: um nome para o mapa de URLs.
      • DEFAULT_BACKEND_SERVICE_NAME: o nome do serviço de back-end predefinido do balanceador de carga. A predefinição é usada quando nenhuma regra de anfitrião corresponde ao nome do anfitrião pedido.
    7. Use o recurso de certificado SSL para criar um proxy HTTPS de destino.

      gcloud compute target-https-proxies create PROXY_NAME \ --url-map=URL_MAP_NAME \ --ssl-certificates=CERTIFICATE \ --region=$RUNTIME_LOCATION --project=$PROJECT_ID

      Substitua o seguinte:

      • PROXY_NAME: um nome para o proxy HTTPS de destino.
      • URL_MAP_NAME: o nome do mapa de URLs.
      • CERTIFICATE: o nome do recurso do certificado.
    8. 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 \ --network=$NETWORK_NAME \ --subnet=$SUBNET_NAME 

      Substitua o seguinte:

      • FWD_RULE: um nome para a regra de encaminhamento.
      • ADDRESS_NAME: o recurso de endereço IP que reservou para usar na regra de encaminhamento.
      • PROXY_NAME: o nome do proxy HTTPS de destino.
      • NETWORK_NAME: (Opcional) Nome da rede na qual o NEG é criado. Se omitir este parâmetro, é usada a rede do projeto default.
      • SUBNET_NAME: nome da sub-rede usada para a conetividade privada ao produtor.
    9. O aprovisionamento do Apigee está concluído. Aceda a Implemente um proxy de exemplo.

    Encaminhamento externo (PSC)

    Esta secção descreve como configurar o encaminhamento externo através do Private Service Connect (PSC) para permitir a comunicação entre o Apigee e as VPCs que controla. Tem de o fazer antes de poder enviar um pedido de um cliente externo para a sua instância do tempo de execução do Apigee.

    Passo 7b: crie um NEG e configure o balanceador de carga

    Pode criar um balanceador de carga global ou regional.

    LB 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 equilíbrio de carga nesta configuração são globais.

    1. Certifique-se de que definiu as variáveis de ambiente em Definir variáveis de ambiente.
    2. Obtenha a associação de serviço da instância que criou 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"

      Na saída de exemplo seguinte, o valor serviceAttachment é apresentado a 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 a associação do serviço que obteve do corpo da resposta da instância no passo 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 o seguinte:

      • NEG_NAME: um nome para o grupo de pontos finais da rede.
      • TARGET_SERVICE: a associação de serviço à qual quer estabelecer ligação. Use o valor da associação de serviço devolvido pelo comando anterior. Por exemplo: projects/bfac7497a40c32a12p-tp/regions/us-west1/serviceAttachments/apigee-us-west1-crw7
      • NETWORK_NAME: (Opcional) Nome da rede na qual o NEG é criado. Se omitir este parâmetro, é usada a rede do projeto default.
      • SUBNET_NAME: nome da sub-rede usada para a conetividade privada ao produtor. O tamanho da sub-rede pode ser pequeno: o NEG do PSC só precisa de um IP da sub-rede. Para o Apigee, só é necessário um NEG do PSC por região. A sub-rede pode ser partilhada e usada por VMs ou outras entidades. Se não for especificada uma sub-rede, os pontos finais de rede podem pertencer a qualquer sub-rede na região onde o grupo de pontos finais de rede é criado.
      • $PROJECT_ID O projeto do Google Cloud que já está associado à sua organização do Apigee ou um projeto do Google Cloud incluído no consumerAcceptlist quando a instância de runtime do Apigee foi criada. Se ainda não o fez, crie uma variável de ambiente para guardar o ID do projeto, uma vez que é usado na maioria dos comandos seguintes.
    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.

    7. Adicione o NEG ao serviço de back-end.
      gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \     --network-endpoint-group=NEG_NAME \     --network-endpoint-group-region=REGION \     --global --project=$PROJECT_ID

      Substitua o seguinte:

      • BACKEND_SERVICE_NAME: o nome do serviço de back-end.
      • NEG_NAME: o nome do grupo de pontos finais da rede.
      • REGION: a região do grupo de pontos finais da rede.
    8. Crie um mapa de URLs para o balanceador de carga.

      Um mapa de URLs tem de fazer referência a um serviço de back-end predefinido. Defina o serviço de back-end que acabou de criar como predefinição.

      gcloud compute url-maps create URL_MAP_NAME \     --default-service=DEFAULT_BACKEND_SERVICE_NAME \     --global --project=$PROJECT_ID

      Substitua o seguinte:

      • URL_MAP_NAME: um nome para o mapa de URLs.
      • DEFAULT_BACKEND_SERVICE_NAME: o nome do serviço de back-end predefinido do balanceador de carga. A predefinição é usada quando nenhuma regra de anfitrião corresponde ao nome do anfitrião pedido.
    9. Crie o proxy HTTPS de destino.

      Para criar um balanceador de carga HTTPS, tem de ter um recurso de certificado SSL para usar no proxy de destino HTTPS. Pode criar um recurso de certificado SSL através de um certificado SSL gerido pela Google ou de um certificado SSL autogerido. A utilização de certificados geridos pela Google é recomendada porque o Google Cloud obtém, gere e renova estes certificados automaticamente.

      Para criar um certificado gerido pela Google, tem de ter um domínio.

      Use este comando para criar um recurso de certificado SSL gerido pela Google:

      gcloud compute ssl-certificates create CERTIFICATE \     --domains DOMAIN --project=$PROJECT_ID

      Substitua o seguinte:

      • CERTIFICATE: um nome para o certificado.
      • DOMAIN: o nome do domínio do seu balanceador de carga.

      Use este comando para criar um recurso de certificado SSL autogerido. Para criar um certificado SSL autogerido, precisa de um ficheiro de chave privada local e um ficheiro de certificado local. Se precisar de criar estes ficheiros, consulte o passo 1 da utilização de certificados SSL autogeridos.

      gcloud compute ssl-certificates create CERTIFICATE \     --certificate LB_CERT \     --private-key LB_PRIVATE_KEY --project=$PROJECT_ID

      Substitua o seguinte:

      • CERTIFICATE: um nome para o certificado.
      • LB_CERT: o caminho para o ficheiro de certificado no formato PEM do seu certificado autogerido.
      • LB_PRIVATE_KEY: o caminho para o ficheiro de chave privada no formato PEM do seu certificado autogerido.

      Use o recurso de certificado SSL para criar um proxy HTTPS de destino.

      gcloud compute target-https-proxies create PROXY_NAME \     --url-map=URL_MAP_NAME \     --ssl-certificates=CERTIFICATE --project=$PROJECT_ID

      Substitua o seguinte:

      • PROXY_NAME: um nome para o proxy HTTPS de destino.
      • URL_MAP_NAME: o nome do mapa de URLs.
      • CERTIFICATE: o nome do recurso do certificado.
    10. 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 o seguinte:

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

    LB externo regional

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

    1. Certifique-se de que definiu as variáveis em Definir variáveis de ambiente.
    2. Crie uma sub-rede só de 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 o seguinte:

      • SUBNET_NAME: o nome da sub-rede.
      • (Opcional) NETWORK_NAME: nome da rede na qual a sub-rede é criada. Se omitir este parâmetro, é usada a rede do projeto predefinida.
    3. Obtenha a associação de serviço da instância que criou 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"

      Na saída de exemplo seguinte, o valor serviceAttachment é apresentado a 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 pontos finais de 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 o seguinte:

      • NEG_NAME: o nome do grupo de pontos finais da rede.
      • TARGET_SERVICE: o nome da associação de serviço à qual quer estabelecer ligação. 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.

    7. Adicione o NEG ao serviço de back-end.
      gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \   --network-endpoint-group=NEG_NAME \   --region=$RUNTIME_LOCATION  \   --project=$PROJECT_ID

      Substitua o seguinte:

      • BACKEND_SERVICE_NAME: o nome do serviço de back-end.
      • NEG_NAME: o nome do grupo de pontos finais da rede.
    8. Crie um mapa de URLs para o balanceador de carga.

      Um mapa de URLs tem de fazer referência a um serviço de back-end predefinido. Defina o serviço de back-end que acabou de criar como predefinição.

      gcloud compute url-maps create URL_MAP_NAME \   --default-service=DEFAULT_BACKEND_SERVICE_NAME \   --region=$RUNTIME_LOCATION  \   --project=$PROJECT_ID

      Substitua o seguinte:

      • URL_MAP_NAME: um nome para o mapa de URLs.
      • DEFAULT_BACKEND_SERVICE_NAME: o nome do serviço de back-end predefinido do balanceador de carga. A predefinição é usada quando nenhuma regra de anfitrião corresponde ao nome do anfitrião pedido.
    9. Crie o proxy HTTPS de destino.

      Para criar um balanceador de carga HTTPS, tem de ter um recurso de certificado SSL para usar no proxy de destino HTTPS.

      Use este comando para criar um recurso de certificado SSL autogerido. Para criar um certificado SSL autogerido, precisa de um ficheiro de chave privada local e um ficheiro de certificado local. Se precisar de criar estes ficheiros, consulte o passo 1 da utilização de certificados SSL autogeridos.

      gcloud compute ssl-certificates create CERTIFICATE \   --certificate LB_CERT \   --private-key LB_PRIVATE_KEY --region=$RUNTIME_LOCATION \   --project=$PROJECT_ID

      Substitua o seguinte:

      • CERTIFICATE: um nome para o certificado.
      • LB_CERT: o caminho para o ficheiro de certificado no formato PEM do seu certificado autogerido.
      • LB_PRIVATE_KEY: o caminho para o ficheiro de chave privada no formato PEM do seu certificado autogerido.

      Use o recurso de certificado SSL para criar um proxy HTTPS de destino.

      gcloud compute target-https-proxies create PROXY_NAME \   --url-map=URL_MAP_NAME --region=$RUNTIME_LOCATION \   --ssl-certificates=CERTIFICATE --project=$PROJECT_ID

      Substitua o seguinte:

      • PROXY_NAME: um nome para o proxy HTTPS de destino.
      • URL_MAP_NAME: o nome do mapa de URLs.
      • CERTIFICATE: o nome do recurso do certificado.
    10. Reserve um endereço externo regional para o balanceador de carga. Tenha em atenção que o nível da rede tem de 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
    11. 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 o seguinte:

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

    O aprovisionamento do Apigee está concluído. Aceda a Implemente um proxy de exemplo.

    Passo 9: implemente um proxy de exemplo

    1. Transfira o proxy de exemplo do GitHub. O destino do proxy é o serviço httpbin.org, que é um serviço público de pedidos e respostas usado com frequência.
    2. Carregue o pacote do proxy de API para o tempo de execução através da API apis do 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'

      Onde PATH_TO_ZIP_FILE é o caminho para o diretório que contém o ficheiro ZIP transferido.

    3. Implemente o proxy de API no ambiente que 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 implementação foi concluída com êxito com esta chamada 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 da API:

      Envie um pedido para o proxy de API a partir de qualquer máquina com ligação à rede executando o seguinte comando:

      curl -i -H "Host: ENV_GROUP_HOSTNAME" \     "https://ENV_GROUP_HOSTNAME/httpbin/headers"

      Se necessário, pode usar esta API para obter 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 receber um erro como este: CONNECT_CR_SRVR_HELLO:sslv3 alert handshake failure, verifique se o certificado SSL que criou anteriormente foi aprovisionado. Use este comando para verificar o estado do aprovisionamento. Quando o certificado é aprovisionado, o respetivo estado é ACTIVE.

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

      Após o êxito, o proxy da API de exemplo devolve 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"     } }

    Para mais informações sobre a implementação de proxies, incluindo informações adicionais de resolução de problemas, consulte o artigo Implementar um proxy de API.