Instalar o Apigee no Google Distributed Cloud com isolamento físico

Este guia descreve como instalar e implantar o Apigee Edge para nuvem privada e proxies de API em um ambiente isolado do Google Distributed Cloud (GDC). As ofertas GDC sem conexão com a Internet, incluindo o Apigee Edge para nuvem privada, não exigem conectividade com o Google Cloud para gerenciar a infraestrutura e os serviços. Você pode usar um plano de controle local hospedado nas suas instalações para todas as operações. Para uma visão geral do GDC com isolamento físico, consulte a visão geral.

Este guia é destinado a operadores do Apigee que conhecem o Apigee Edge para nuvem privada e têm uma compreensão básica do Kubernetes.

Visão geral das etapas necessárias

Para instalar e implantar o Apigee Edge para nuvem privada em um ambiente GDC isolado, o operador precisa concluir as seguintes etapas:

Antes de começar

Antes de iniciar o processo de instalação, conclua as etapas a seguir:

  1. Crie um projeto do GDC para usar na instalação, se você ainda não tiver um. Para ver mais informações, consulte Criar um projeto.
  2. Faça o download, instale e configure a CLI gdcloud em uma estação de trabalho conectada ao GDC ou no ambiente de implantação contínua da sua organização.
  3. Receba as credenciais necessárias para usar a CLI gdcloud e a API kubectl. Consulte Autenticar sua conta para acesso e siga as etapas necessárias.
  4. Confirme o nome de usuário e a senha da Apigee que você recebeu do gerente da sua conta da Apigee.
  5. Confirme o nome do cluster de administrador do GKE e do cluster de usuário do GKE.

Requisitos de capacidade

A instalação do Apigee Edge para nuvem privada no GDC exige várias máquinas virtuais (VMs) com alocações de recursos específicas. Essas VMs geram cobranças com base nos recursos de computação (RAM, núcleos de vCPU) e no armazenamento em disco local. Para mais informações, consulte Preços.

A tabela a seguir mostra os requisitos de recursos para cada VM:

Tipo de VM RAM Núcleos de vCPU Armazenamento em disco
Nó do repositório 8 GB Núcleos de 2 vCPUs 64 GB
Nó de controle 8 GB Núcleos de 2 vCPUs 64 GB
Nós 1, 2 e 3 do gerenciamento de APIs da Apigee 16 GB de RAM 8 núcleos de vCPU 670 GB
Nós 4 e 5 do gerenciamento de APIs da Apigee 16 GB de RAM 8 núcleos de vCPU 500 GB a 1 TB

Papéis e permissões

Os seguintes papéis e permissões são necessários para implantar o Apigee Edge para nuvem privada em um ambiente do GDC isolado:

  • Administrador da plataforma (PA): atribua a função IAM Admin.
  • Operador de aplicativo (AO): atribua os seguintes papéis:
    • Harbor Instance Admin: tem acesso total para gerenciar instâncias do Harbor em um projeto.
    • LoggingTarget Creator: cria recursos personalizados LoggingTarget no namespace do projeto.
    • LoggingTarget Editor: edita recursos personalizados LoggingTarget no namespace do projeto.
    • Project Bucket Admin: gerencia os buckets de armazenamento e os objetos dentro deles.
    • Project Grafana Viewer: acessa a instância de monitoramento no namespace do projeto.
    • Project NetworkPolicy Admin: gerencia as políticas de rede do projeto no namespace do projeto.
    • Project VirtualMachine Admin: gerencia as máquinas virtuais no namespace do projeto.
    • Secret Admin: gerencia secrets do Kubernetes em projetos.
    • Service Configuration Admin: tem acesso de leitura e gravação às configurações de serviço em um namespace de projeto.
    • Namespace Admin: gerencia todos os recursos nos namespaces do projeto.

    • Para saber mais sobre como conceder papéis e permissões isolados do GDC, consulte Conceder e revogar acesso.

    Limitações

    As seguintes limitações se aplicam ao Apigee no GDC isolado por ar:

    • O Apigee no GDC isolado por air-gap não vem com servidores DNS e usa a resolução de DNS local como solução alternativa. Se o Apigee no GDC isolado por air-gap for implantado em um ambiente com servidores DNS externos, substitua as etapas que configuram o DNS local pela configuração de entradas DNS nos servidores DNS.
    • A Apigee em GDC isolado por air-gap não inclui um servidor SMTP independente. É possível configurar um servidor SMTP a qualquer momento para ativar as notificações por e-mail de saída para criação de contas e redefinições de senha no servidor de gerenciamento e na interface de gerenciamento. As APIs de gerenciamento continuam disponíveis para o gerenciamento de contas de usuário do Apigee. Consulte Como configurar o servidor SMTP de borda para mais informações.
    • A Apigee no GDC isolado por air-gap não implementa detecção e prevenção de intrusões. Instale e configure um sistema de prevenção de intrusões (IPS), como o Snort (em inglês), para detectar e evitar atividades maliciosas.

    Baixar os arquivos necessários

    Para receber os arquivos de instalação, primeiro configure um nó conectado e faça o download dos arquivos.

    Configurar um nó conectado

    O nó conectado é uma única VM fora do GDC que você usa para fazer o download dos arquivos de instalação. Essa VM exige acesso à Internet e é usada apenas para o processo de instalação.

    O nó conectado precisa da seguinte capacidade e configuração:

    • Sistema operacional:Rocky Linux 8
    • Tamanho da máquina:8 GB de RAM, 2 núcleos de vCPU e 64 GB de armazenamento em disco local
    • Conectividade:
      • Entrada:TCP 22 (SSH)
      • Saída:Internet

    Para criar o nó conectado, siga as instruções em Criar e iniciar uma instância de VM. Depois que a VM for criada, siga as instruções em Conectar-se a VMs Linux. para se conectar à VM. Consulte Sistemas operacionais compatíveis com o GDC para uma lista de sistemas operacionais compatíveis.

    Fazer o download dos arquivos de instalação

    Para fazer o download dos arquivos de instalação:

    1. Confira as notas da versão do Apigee Edge para nuvem privada para saber a versão oficial mais recente compatível com o GDC, conforme indicado na coluna "Edge para nuvem privada".
    2. Faça o download do arquivo de configuração do Edge: 
      curl https://software.apigee.com/apigee/tarball/VERSION/rocky8/archive.tar -o /tmp/archive.tar -u 'APIGEE_USER:APIGEE_PASSWORD'

      Em que:

      • APIGEE_USER é o nome de usuário que você recebeu para a organização da Apigee.
      • APIGEE_PASSWORD é a senha que você recebeu para a organização da Apigee.
      • VERSION é a versão do Apigee Edge para nuvem privada a ser usada no GDC que você quer instalar, por exemplo, 4.53.01.
    3. Faça o download do arquivo bootstrap_VERSION.sh mais recente do Apigee Edge para nuvem privada em /tmp/bootstrap_VERSION.sh: 
      curl https://software.apigee.com/bootstrap_VERSION.sh -o /tmp/bootstrap_VERSION.sh

      Em que VERSION é a versão mais recente do Apigee Edge para nuvem privada a ser usada no GDC que você quer instalar, por exemplo, 4.53.01.

    4. Instale o utilitário e as dependências do Edge apigee-service: 
      sudo bash /tmp/bootstrap_VERSION.sh apigeeuser=APIGEE_USER apigeepassword=APIGEE_PASSWORD

      Em que:

      • APIGEE_USER é o nome de usuário que você recebeu para a organização da Apigee.
      • APIGEE_PASSWORD é a senha que você recebeu para a organização da Apigee.
      • VERSION é a versão do Apigee Edge para nuvem privada que será usada no GDC que você quer instalar.

    5. Execute o script de configuração no nó conectado: 
      chmod a+x connected-node_setup.sh \
  ./connected-node_setup.sh

      Nesta etapa, o script gera os arquivos necessários nos seguintes locais (por exemplo, para a versão 4.53.01):

      • /opt/apigee/data/apigee-mirror/apigee-4.53.01.tar.gz
      • /tmp/apigee-nginx/apigee-nginx.tar
      • /tmp/fluentbit/fluentbit.tar
      • /tmp/postgresql14/postgresql14.tar
      • /tmp/ansible-rpms.tar
      • /tmp/apigee-repos.tar
    6. Transfira os arquivos necessários do nó conectado para uma máquina local via SSH: 
      mkdir apigee-files
cd apigee-files
for file in /opt/apigee/data/apigee-mirror/apigee-4.53.01.tar.gz /tmp/ansible-rpms.tar /tmp/apigee-nginx/apigee-nginx.tar /tmp/fluentbit/fluentbit.tar /tmp/postgresql14/postgresql14.tar /tmp/apigee-repos.tar; do
  scp -i SSH_PRIVATE_KEY_FILE USER@CONNECTED_NODE_IP:$file .
  done

      Em que:

      • SSH_PRIVATE_KEY_FILE é o caminho para o arquivo de chave privada SSH.
      • USER é o nome de usuário do nó conectado.
      • CONNECTED_NODE_IP é o endereço IP do nó conectado.

    Configurar o bucket de armazenamento

    Nesta etapa, o operador do GDC configura um bucket de armazenamento no projeto do GDC para armazenar os arquivos de backup do Apigee Edge para nuvem privada.

    Criar um bucket de armazenamento

    Para criar um bucket de armazenamento no projeto do GDC:

    1. Autentique-se com o cluster de administrador da organização: 
      gdcloud auth login --login-config-cert WEB_TLS_CERT
gdcloud clusters get-credentials ORG_ADMIN_CLUSTER

      Em que:

      • WEB_TLS_CERT é o caminho para o certificado TLS da Web.
      • ORG_ADMIN_CLUSTER é o nome do cluster do GKE do administrador da organização.

    2. Defina as variáveis de ambiente do projeto e do bucket: 
      export PROJECT=PROJECT
export BUCKET=BUCKET_NAME

      Em que:

      • PROJECT é o nome do seu projeto do GDC.
      • BUCKET_NAME é o nome do bucket que você quer criar para armazenar os arquivos de backup do Apigee Edge para nuvem privada.
    3. Aplique a configuração do bucket: 
      kubectl apply -f - <<EOF
apiVersion: object.GDC.goog/v1
kind: Bucket
metadata:
  name: $BUCKET
  namespace:$PROJECT
spec:
  description: bucket for Apigee backup files
  storageClass: Standard
  bucketPolicy :
    lockingPolicy :
      defaultObjectRetentionDays: 30
EOF

      Essa configuração cria um bucket com um período de retenção de 30 dias.

    Configurar o acesso ao bucket

    Para configurar o acesso ao bucket de armazenamento:

    1. Crie uma conta de serviço no projeto: 
      gdcloud iam service-accounts create $BUCKET-sa \
    --project=$PROJECT
    2. Crie a função e a vinculação de função para gerar um secret de acesso ao bucket: 
      kubectl apply -f - <<EOF
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: $BUCKET-role
  namespace: $PROJECT
rules:
-   apiGroups:
  -   object.gdc.goog
  resourceNames:
  -   $BUCKET
  resources:
  -   buckets
  verbs:
  -   get
  -   read-object
  -   write-object
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: $BUCKETrolebinding
  namespace: $PROJECT
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: Role
  name: $BUCKET-role
subjects:
-   kind: ServiceAccount
  name: $BUCKET-sa
  namespace: $PROJECT
EOF
    3. Receba o ID e a chave de acesso do secret: 
      export BUCKET_SECRET=$(kubectl get secret -n $PROJECT -o jsonpath="{range .items[*]}{.metadata.name}{':'}{.metadata.annotations['object\.GDC\.goog/subject']}{'\n'}{end}" | grep $BUCKET | tail -1 | cut -f1 -d :)
echo "access-key-id=$(kubectl get secret -n $PROJECT $BUCKET_SECRET -o jsonpath="{.data['access-key-id']}")"
echo "access-key=$(kubectl get secret -n $PROJECT $BUCKET_SECRET -o jsonpath="{.data['secret-access-key']}")"

      A saída será parecida com esta: 

      access-key-id=RFdJMzRROVdWWjFYNTJFTzJaTk0=
access-key=U3dSdm5FRU5WdDhMckRMRW1QRGV0bE9MRHpCZ0Ntc0cxVFJQdktqdg==
    4. Crie um secret para ser usado pelo uploader no cluster do GKE do usuário:
      1. Autentique com o cluster de usuário do GKE: 
        gdcloud clusters get-credentials USER_CLUSTER

        Em que USER_CLUSTER é o nome do cluster do GKE do usuário.

      2. Aplique a configuração do Secret: 
        kubectl apply -f - <<EOF
apiVersion: v1
kind: Secret
metadata:
  namespace: $PROJECT
  name: $BUCKET-secret
type: Opaque
data:
  access-key-id: ACCESS_KEY_ID
  access-key: ACCESS_KEY
EOF

        Em que:

        • ACCESS_KEY_ID é o ID da chave de acesso obtido na etapa anterior.
        • ACCESS_KEY é a chave de acesso obtida na etapa anterior.
    5. Receba o endpoint de armazenamento, o nome de domínio totalmente qualificado (FQDN) e a região do bucket:
      1. Autentique-se com o cluster de administrador da organização: 
        gdcloud clusters get-credentials ORG_ADMIN_CLUSTER

        Em que ORG_ADMIN_CLUSTER é o nome do cluster do GKE do administrador da organização.

      2. Receba o endpoint de armazenamento, o nome de domínio totalmente qualificado (FQDN) e a região do bucket: 
        kubectl get buckets ${BUCKET} -n $PROJECT -o jsonpath="{'endpoint: '}{.status.endpoint}{'\n'}{'bucket: '}{.status.fullyQualifiedName}{'\n'}{'region: '}{.status.region}{'\n'}"

        A saída será parecida com esta:

        endpoint: https://objectstorage.gpu-org.cookie.sesame.street
bucket: ez9wo-apigee-backup-bucket
region: cookie
    6. Atualize os seguintes valores no arquivo apigee/helm_user_cluster/values-cookie-air-gapped.yaml: 
      objectstorekeyname: "apigee-backup-bucket-secret"
objectstoreurl: "BUCKET_ENDPOINT"
objectstorebucket: "BUCKET_FQDN"

      Em que:

      • BUCKET_ENDPOINT é o endpoint do bucket obtido na etapa anterior.
      • BUCKET_FQDN é o nome de domínio totalmente qualificado do bucket obtido na etapa anterior.

    Configurar o nó do repositório

    Nesta etapa, o operador do GDC configura um nó de repositório para hospedar o repositório espelhado do Apigee Edge para nuvem privada.

    Criar um nó de repositório

    Para criar um nó de repositório:

    1. Atualize o apigee/helm_user_cluster/values-cookie-air-gapped.yaml desta maneira: 
      repo_node:
  enabled: true

apigee_node:
  enabled: false

control_node:
  enabled: false

      Verifique se o repo_node está ativado e se apigee_node e control_node estão desativados. Esses nós serão implantados em uma etapa posterior.

    2. Receba as credenciais do cluster de administrador da organização: 
      gdcloud clusters get-credentials ORG_ADMIN_CLUSTER

      Em que ORG_ADMIN_CLUSTER é o nome do cluster do GKE do administrador da organização.

    3. Crie um ambiente virtual em Python: 
      python3 -m venv venv /
source venv/bin/activate
    4. Execute o script de implantação para criar o nó do repositório: 
      python apigee/solution_deploy.py gdc-air-gapped

    Configurar o acesso ao nó do repositório

    Para configurar o acesso ao nó do repositório:

    1. Configure o SSH para o nó do repositório: 
      export NODE=repo
kubectl create -n $PROJECT -f - <<EOF
  apiVersion: virtualmachine.GDC.goog/v1
  kind: VirtualMachineAccessRequest
  metadata:
    generateName: $NODE-
  spec:
    ssh:
      key: |
        "cat SSH_PUBLIC_KEY_FILE"
  ttl: 24h
  user: admin
  vm: $NODE
  EOF

      Em que SSH_PUBLIC_KEY_FILE é o nome do arquivo que contém sua chave SSH pública.

    2. Encontre o endereço IP externo do nó do repositório: 
      kubectl get virtualmachineexternalaccess -n $PROJECT $NODE -ojsonpath='{.status.ingressIP}'
    3. Consiga o endereço IP interno do nó do repositório: 
      kubectl get virtualmachines.virtualmachine.gdc.goog -n $PROJECT $NODE -ojsonpath='{.status.network.interfaces[1].ipAddresses[0]}'

    Faça upload de arquivos de instalação

    Nesta etapa, o operador do GDC faz upload da versão mais recente dos seguintes arquivos para o nó do repositório:

    • apigee-4.53.01
    • apigee-nginx.tar
    • postgresql14.tar
    • fluentbit.tar
    • ansible-rpms.tar
    • apigee-repos.tar

    Para fazer upload dos arquivos de instalação:

    1. Copie o arquivo de chave privada SSH para o nó do repositório: 
      scp -i SSH_PRIVATE_KEY_FILE ~/apigee-files/* admin@REPO_EXTERNAL_IP:/tmp

      Em que:

      • SSH_PRIVATE_KEY_FILE é o nome do arquivo que contém sua chave privada SSH.
      • REPO_EXTERNAL_IP é o endereço IP externo do nó do repositório obtido na etapa anterior.
    2. Faça upload da pasta com as configurações do Fluent Bit para o nó do repositório: 
      scp -i SSH-PRIVATE-KEY-FILE -r apigee/scripts/fluent-bit admin@REPO_EXTERNAL_IP:/tmp/fluent-bit

      Em que:

      • SSH_PRIVATE_KEY_FILE é o nome do arquivo que contém sua chave privada SSH.
      • REPO_EXTERNAL_IP é o endereço IP externo do nó do repositório.

    Configurar o repositório espelhado

    Para configurar o repositório de espelho:

    1. Copie apigee/scripts/repo_setup.sh para o nó do repositório.
    2. No script, substitua REPO_USER e REPO_PASSWORD pelo nome de usuário e senha desejados para o repositório espelhado.
    3. Execute o script: 
      chmod a+x repo_setup.sh
./repo_setup.sh

      Se você encontrar um erro No such file or directory, execute o script novamente.

    4. Teste a conexão com o repositório espelhado localmente no nó do repositório. 
      curl http://REPO_USER:REPO_PASSWORD@REPO_INTERNAL_IP:3939/bootstrap_VERSION.sh -o /tmp/bootstrap_VERSION.sh
curl http://REPO_USER:REPO_PASSWORD@REPO_INTERNAL_IP:3939/apigee/release/VERSION/repodata/repomd.xml

      Substitua VERSION pela versão do Apigee Edge para nuvem privada que você quer instalar.

    Implantar nós da Apigee

    Nesta etapa, o operador do GDC implanta os nós de gerenciamento de API do Apigee.

    Criar nós da Apigee

    Para criar os nós de gerenciamento de API da Apigee:

    1. Substitua REPO_INTERNAL_IP, REPO_USER_NAME e REPO_PASSWORD em apigee/helm/scripts/apigee_setup.sh pelos valores desejados.
    2. Exporte os valores como variáveis de ambiente: 
      export REPO_IP=REPO_INTERNAL_IP
export REPO_USER=REPO_USER_NAME
export REPO_PASSWORD=REPO_PASSWORD
    3. Ative o apigee_node em apigee/helm/values-cookie-air-gapped.yaml, conforme mostrado:: 
      apigee_node:
  enabled: true
    4. Execute o script de implantação para criar os nós do Apigee: 
        source venv/bin/activate
  python apigee/solution_deploy.py gdc-air-gapped

    Configurar o acesso ao nó da Apigee

    Configure o acesso aos nós de gerenciamento da API Apigee:

    1. Autentique-se com o cluster de administrador da organização: 
      gdcloud clusters get-credentials ORG_ADMIN_CLUSTER

      Em que ORG_ADMIN_CLUSTER é o nome do cluster do GKE do administrador da organização.

    2. Crie uma chave SSH para cada nó: 
      for i in 1 2 3 4 5; do
  kubectl create -n $PROJECT -f - <<EOF
  apiVersion: virtualmachine.GDC.goog/v1
  kind: VirtualMachineAccessRequest
  metadata:
    generateName: node$i
  spec:
    ssh:
      key: |
        "cat SSH_PUBLIC_KEY_FILE"
  ttl: 24h
  user: admin
  vm: node$i
  EOF
  done

      Em que SSH_PUBLIC_KEY_FILE é o nome do arquivo que contém sua chave SSH pública.

    3. Encontre os endereços IP externos dos nós do Apigee: 
      for i in 1 2 3 4 5; do
  kubectl get virtualmachineexternalaccess -n $PROJECT node$i -ojsonpath='{.status.ingressIP}'
  echo
  done
    4. Encontre os endereços IP internos dos nós do Apigee: 
      for i in 1 2 3 4 5; do
  kubectl get virtualmachines.virtualmachine.gdc.goog -n $PROJECT node$i -ojsonpath='{.status.network.interfaces[1].ipAddresses[0]}'
  echo
  done
    5. (Opcional) Verifique se os scripts de inicialização foram executados com sucesso nos nós do Apigee:
      1. Use SSH no nó e execute o seguinte comando: 
        sudo journalctl -u cloud-final -f
      2. Procure registros semelhantes a estes: 
        Aug 29 18:17:00 172.20.128.117 cloud-init[1895]: Complete!
Aug 29 18:17:00 172.20.128.117 cloud-init[1895]: Finished running the command: . /var/lib/google/startup-scripts/apigee-setup

    Configurar o nó de controle

    Nesta etapa, o operador do GDC configura um nó de controle para gerenciar as instalações da Apigee.

    Criar um nó de controle

    Para criar um nó de controle:

    1. Substitua REPO_INTERNAL_IP, REPO_USER_NAME e REPO_PASSWORD em apigee/helm/scripts/control_setup.sh pelos valores desejados.
    2. Ative o control_node em apigee/helm/values-cookie-air-gapped.yaml, conforme mostrado: 
      control_node:
  enabled: true
    3. Execute o script de implantação para criar o nó de controle: 
      source venv/bin/activate
python apigee/solution_deploy.py gdc-air-gapped

    Configurar o acesso ao nó de controle

    Para configurar o acesso ao nó de controle:

    1. Configure o acesso SSH ao nó de controle: 
      kubectl create -n $PROJECT -f - <<EOF
apiVersion: virtualmachine.GDC.goog/v1
kind: VirtualMachineAccessRequest
metadata:
  generateName: control-
spec:
  ssh:
    key: |
      "cat SSH_PUBLIC_KEY_FILE"
ttl: 24h
user: admin
vm: control
EOF
    2. Encontre o endereço IP externo do nó de controle: 
      kubectl get virtualmachineexternalaccess -n $PROJECT control -ojsonpath='{.status.ingressIP}'
    3. Consiga o IP interno do nó de controle: 
      kubectl get virtualmachines.virtualmachine.GDC.goog -n $PROJECT control -ojsonpath='{.status.network.interfaces[1].ipAddresses[0]}'

    Configurar o Ansible

    Nesta etapa, o operador do GDC configura o ambiente no nó de controle.

    Para configurar o ambiente do Ansible:

    1. Use SSH no nó de controle e configure o ambiente do Ansible: 
      cd /home/admin
cp -r /tmp/apigee-repos .
cd apigee-repos/ansible-opdk-accelerator/setup
    2. Substitua repositórios git remotos por um arquivo local: 
      sed -i 's/https:\/\/github.com\/carlosfrias/git+file:\/\/\/home\/admin\/apigee-repos/g'  requirements.yml
sed -i 's/\.git$//g'  requirements.yml
    3. Install Ansible requirements: 
        sudo chown -R admin /home/admin/apigee-repos
  ansible-galaxy install -r requirements.yml -f
    4. Atualize a configuração de instalação:
      1. Edite o arquivo main.yml: 
        vi ~/apigee-repos/ansible-opdk-accelerator/setup/roles/apigee-opdk-setup-ansible-controller/tasks/main.yml
      2. Remova as tarefas que precisam de acesso ao GitHub:
        • Checkout SSH do Git de repositórios de configuração
        • Checkout HTTPS do Git de repositórios de configuração
      3. Execute o playbook de configuração: 
        cd ~/apigee-repos/ansible-opdk-accelerator/setup
ansible-playbook setup.yml
    5. Faça upload da chave SSH para os nós do Apigee no nó de controle: 
      scp -i CONTROL_SSH_PRIVATE_KEY_FILE APIGEE_NODE_SSH_PRIVATE_KEY_FILE admin@CONTROL_EXTERNAL_IP:/home/admin/.ssh/id_rsa

      Em que:

      • CONTROL_SSH_PRIVATE_KEY_FILE é o nome do arquivo que contém a chave privada SSH do nó de controle.
      • APIGEE_NODE_SSH_PRIVATE_KEY_FILE é o nome do arquivo que contém a chave privada SSH do nó do Apigee.
      • CONTROL_EXTERNAL_IP é o endereço IP externo do nó de controle.
    6. Crie o arquivo de configuração de inventário do Ansible:
      1. Copie o conteúdo do arquivo apigee/scripts/ansible/prod.cfg para o arquivo prod.cfg: 
        vi ~/.ansible/multi-planet-configurations/prod.cfg
      2. Crie a pasta edge-dc1 e copie o conteúdo do arquivo apigee/scripts/ansible/edge-dc1 para o arquivo edge-dc1: 
        mkdir ~/.ansible/inventory/prod
vi ~/.ansible/inventory/prod/edge-dc1
    7. Atualize os endereços IP internos dos nós da Apigee em edge-dc1: 
      apigee_000 ansible_host=APIGEE_NODE1_INTERNAL_IP
apigee_001 ansible_host=APIGEE_NODE2_INTERNAL_IP
apigee_002 ansible_host=APIGEE_NODE3_INTERNAL_IP
apigee_003 ansible_host=APIGEE_NODE4_INTERNAL_IP
apigee_004 ansible_host=APIGEE_NODE5_INTERNAL_IP

      Em que os valores de APIGEE_NODE*_INTERNAL_IP são os endereços IP internos dos nós do Apigee obtidos em uma etapa anterior.

    8. Configure o arquivo ~/.apigee-secure/credentials.yml com os seguintes valores:
      • apigee_repo_user: 'APIGEE_REPO_USER'
      • apigee_repo_password: 'APIGEE_REPO_PASSWORD'
      • opdk_qpid_mgmt_username: 'OPDK_QPID_MGMT_USERNAME'
      • opdk_qpid_mgmt_password: 'OPDK_QPID_MGMT_PASSWORD'

      Em que:

      • APIGEE_REPO_USER é o nome de usuário do repositório da Apigee.
      • APIGEE_REPO_PASSWORD é a senha do repositório da Apigee.
      • OPDK_QPID_MGMT_USERNAME é o nome de usuário do servidor de gerenciamento do QPID da Apigee.
      • OPDK_QPID_MGMT_PASSWORD é a senha do servidor de gerenciamento do QPID da Apigee.

    9. Adicione um arquivo de licença válido do Apigee Edge para nuvem privada. O nome do arquivo precisa ser license.txt.
    10. Copie o conteúdo do arquivo ~/.apigee-secure/license.txt para o license.txt que você acabou de criar.
    11. Configure os seguintes valores no arquivo ~/.apigee/custom-properties.yml:
      • opdk_version: 'OPDK_VERSION'
      • apigee_repo_url: 'APIGEE_REPO_URL'

      Em que:

      • OPDK_VERSION é a versão do Apigee Edge para nuvem privada que você quer instalar.
      • APIGEE_REPO_URL é o URL do repositório da Apigee.

    12. Exporte o arquivo de configuração como uma variável de ambiente: 
      export ANSIBLE_CONFIG=~/.ansible/multi-planet-configurations/prod.cfg

    Instalar os componentes da Apigee

    Nesta etapa, o operador do GDC instala os componentes da Apigee usando o Ansible.

    Para instalar os componentes da Apigee:

    1. Substitua os repositórios git remotos por arquivos locais: 
      cd ~/apigee-repos/ansible-opdk-accelerator/installations/multi-node/
sed -i 's/https:\/\/github.com\/carlosfrias/git+file:\/\/\/home\/admin\/apigee-repos/g' requirements.yml
sed -i 's/\.git$//g'  requirements.yml
    2. Instale os requisitos do Ansible: 
      ansible-galaxy install -r requirements.yml -f
    3. Faça o patch das funções do Ansible: 
      sed -i 's/private_address/inventory_hostname/g' ~/.ansible/roles/apigee-opdk-settings-cassandra/tasks/main.yml
sed -i 's/include/include_tasks/g' ~/.ansible/roles/apigee-opdk-server-self/tasks/main.yml
sed -i 's/include/include_tasks/g' ~/.ansible/roles/apigee-opdk-setup-silent-installation-config/tasks/main.yml
cat << EOF >> ~/.ansible/roles/apigee-opdk-setup-silent-installation-config/templates/response-file-template.conf.j2
QPID_MGMT_USERNAME= opdk_qpid_mgmt_username
QPID_MGMT_PASSWORD= opdk_qpid_mgmt_password
EOF
sed -i 's/mode: 0700/mode: 0700\n      recurse: yes/g' ~/.ansible/roles/apigee-opdk-setup-postgres-config/tasks/main.yml
    4. Substitua o conteúdo do arquivo install.yml pelo conteúdo em apigee/scripts/ansible/install.yml.
    5. Execute o playbook para instalar os componentes da Apigee: 
      ansible-playbook install.yml
    6. Desative o link de redefinição de senha do usuário na interface do Edge. O Apigee no GDC isolado por air gap não inclui um servidor SMTP. Siga as etapas em Desativar o link de redefinição de senha na interface do Edge.

    Implantar pods e serviços

    Nesta etapa, você vai implantar os pods e serviços de uploader, proxy reverso, balanceador de carga e geração de registros.

    Para implantar os pods e serviços:

    1. Siga as instruções em Criar instâncias do registro do Harbor para criar uma instância do Harbor no projeto do GDC dev-apigee.
    2. Siga as instruções em Criar projetos do Harbor para criar um projeto do Harbor chamado apigee.
    3. Siga as instruções em Configurar controle de acesso para configurar o controle de acesso do projeto do Harbor.
    4. Siga as instruções em Fazer login no Docker e no Helm para configurar a autenticação do Docker.
    5. Atualize os endereços IP no arquivo apigee/apigee_user_cluster.toml, conforme mostrado: 
      mgmt-server-proxy = "APIGEE_NODE1_EXTERNAL_IP"
router-proxy1 = "APIGEE_NODE2_EXTERNAL_IP"
router-proxy2 = "APIGEE_NODE3_EXTERNAL_IP"

      Em que:

      • APIGEE_NODE1_EXTERNAL_IP é o endereço IP externo do node1 do Apigee obtido em uma etapa anterior.
      • APIGEE_NODE2_EXTERNAL_IP é o endereço IP externo do node2 do Apigee obtido em uma etapa anterior.
      • APIGEE_NODE3_EXTERNAL_IP é o endereço IP externo do node3 do Apigee obtido em uma etapa anterior.

    6. Coloque o arquivo de certificado SSL (server.crt) e o arquivo de chave (server.key) para configurar o HTTPS nas pastas apigee/mgmt-server-proxy e apigee/router-proxy.

      Para gerar certificados autoassinados, use o seguinte comando: 

      openssl req -newkey rsa:4096 -x509 -nodes -keyout server.key -new -out server.crt -subj "/CN=*.apigeetest.com" -sha256 -days 365
    7. Atualize o valor de SSH-PASSWORD para o usuário raiz no contêiner de upload no arquivo apigee/uploader/Dockerfile: 
      RUN echo 'root:SSH_PASSWORD' | chpasswd
    8. Receba as credenciais do cluster de usuário: 
      gdcloud clusters get-credentials USER_CLUSTER

      Em que USER_CLUSTER é o nome do cluster do GKE do usuário.

    9. Execute o script de implantação para implantar os pods e serviços: 
      source venv/bin/activate
python apigee/solution_deploy_user_cluster.py gdc-air-gapped
    10. Encontre os endereços IP externos dos serviços: 
      kubectl get svc -n $PROJECT_ID

    Atualizar os IPs do uploader e do encaminhador do Fluent Bit

    Nesta etapa, você vai atualizar os IPs do uploader e do encaminhador do Fluent Bit nos scripts de backup e configuração da Apigee.

    1. Atualize SSH_PASSWORD, root e UPLOADER_EXTERNAL_IP em apigee/helm/scripts/backup_setup.sh: 
      sshpass -p SSH_PASSWORD scp -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null apigee-backup* root@UPLOADER_EXTERNAL_IP:/temp/

      Em que:

      • SSH_PASSWORD é a senha do usuário raiz.
      • UPLOADER_EXTERNAL_IP é o endereço IP externo do serviço de upload obtido em uma etapa anterior.

    2. Atualize FLUENTBIT_EXTERNAL_IP em apigee/helm/scripts/apigee_setup.sh: 
      export FLUENTBIT_EXTERNAL_IP=FLUENTBIT_EXTERNAL_IP

    Para atualizar o script de inicialização, é necessário reiniciar os nós do Apigee. Para reiniciar os nós:

    1. Pare as VMs: 
      gdcloud clusters get-credentials ORG_ADMIN_CLUSTER
export PROJECT=dev-apigee
for i in 1 2 3 4 5; do
  gdcloud compute instances stop node$i --project $PROJECT
  done
    2. Implante o gráfico do Helm novamente: 
      python apigee/solution_deploy.py gdc-air-gapped
    3. Inicie as VMs: 
      for i in 1 2 3 4 5; do
  GDCloud compute instances start node$i --project $PROJECT
  done

    Integrar a organização da Apigee

    Nesta etapa, o operador do GDC integra a organização da Apigee executando um script de configuração em node1.

    Para integrar a organização da Apigee:

    1. Atualize os seguintes valores em apigee/scripts/apigee_org_setup.sh, conforme mostrado. Atualize outros parâmetros conforme necessário. 
      IP1=APIGEE_NODE1_INTERNAL_IP

VHOST_ALIAS="APIGEE_NODE2_EXTERNAL_IP:9001 APIGEE_NODE3_EXTERNAL_IP:9001"

      Em que:

      • APIGEE_NODE1_INTERNAL_IP é o endereço IP interno do node1 do Apigee obtido em uma etapa anterior.
      • APIGEE_NODE2_EXTERNAL_IP é o endereço IP externo do node2 do Apigee obtido em uma etapa anterior.
      • APIGEE_NODE3_EXTERNAL_IP é o endereço IP externo do node3 do Apigee obtido em uma etapa anterior.

    2. Execute o script em node1 para integrar a organização: 
      chmod a+x apigee_org_setup.sh
./apigee_org_setup.sh

    Teste a conectividade HTTP

    Nesta etapa, você vai testar a conectividade HTTP da API Management e do proxy de API.

    Para testar a conectividade HTTP:

    1. Encontre o endereço IP externo do serviço apigee-elb: 
      gdcloud clusters get-credentials USER_CLUSTER
export PROJECT=dev-apigee
kubectl get svc apigee-elb -n $PROJECT

      Em que USER_CLUSTER é o nome do cluster do GKE do usuário.

      Esse serviço atua como o endpoint da IU do Edge, da API Management e do proxy de API.

    Testar a API Management

    Para testar a API Management, envie uma solicitação HTTP ao endpoint: 

    curl -u "opdk@apigee.com:Apigee123!" "http://APIGEE_ELB_EXTERNAL_IP:8080/v1/o/ORG_NAME/e/ENV_NAME/provisioning/axstatus"

    Em que:

    • APIGEE_ELB_EXTERNAL_IP é o endereço IP externo do serviço apigee-elb obtido em uma etapa anterior.
    • ORG_NAME é o nome da organização da Apigee.
    • ENV_NAME é o nome do ambiente da Apigee.

    Testar o proxy de API

    Para testar o proxy de API:

    1. Faça login na interface do Edge.
    2. Na página Proxies de API, clique em Criar para criar um proxy de API.
    3. Na página Detalhes do proxy, insira os seguintes valores:
      • Tipo de proxy:selecione Sem destino.
      • Nome do proxy:ok
      • Caminho base: /ok
      • Destino:http://APIGEE_ELB_EXTERNAL_IP:9001
    4. Clique em Criar para criar o proxy de API.
    5. Envie uma solicitação HTTP para /ok: 
      curl -i http://APIGEE_ELB_EXTERNAL_IP:9001/ok
    6. Confirme se a resposta é 200 OK.

    Configurar TLS e testar HTTPS

    Nesta etapa, o operador do GDC configura a segurança da camada de transporte (TLS) para o proxy de API, a interface do Edge e a API Management.

    Configurar o TLS para o proxy de API

    1. Siga as etapas em Criar um keystore/truststore e um alias para criar um certificado autoassinado com os seguintes valores:
      • KeyStore:myTestKeystore
      • KeyAlias:myKeyAlias
      • Nome comum:apigeetest.com
    2. Faça uma chamada de API para criar o host virtual chamado api.apigeetest.com: 
      curl -v -H "Content-Type:application/xml" \
  -u "opdk@apigee.com:Apigee123!" "http://APIGEE_ELB_EXTERNAL_IP:8080/v1/o/ORG_NAME/e//virtualhosts" \
  -d '<VirtualHost  name="secure">
      <HostAliases>
        <HostAlias>api.apigeetest.com</HostAlias>
      </HostAliases>
      <Interfaces/>
      <Port>9005</Port>
      <OCSPStapling>off</OCSPStapling>
      <SSLInfo>
        <Enabled>true</Enabled>
        <ClientAuthEnabled>false</ClientAuthEnabled>
        <KeyStore>myTestKeystore</KeyStore>
        <KeyAlias>myKeyAlias</KeyAlias>
      </SSLInfo>
    </VirtualHost>'

      Em que:

      • APIGEE_ELB_EXTERNAL_IP é o endereço IP externo do serviço apigee-elb obtido em uma etapa anterior.
      • ORG_NAME é o nome da organização da Apigee.
      • ENV_NAME é o nome do ambiente da Apigee em que o host virtual será criado.
    3. Crie um proxy de API usando o host virtual seguro.
    4. Nos roteadores, configure a resolução de DNS para hosts virtuais: 
      echo '127.0.0.1 api.apigeetest.com' | sudo tee -a /etc/hosts
    5. Confirme se os hosts virtuais funcionam localmente enviando uma solicitação HTTPS para o endpoint: 
      curl https://api.apigeetest.com:9005/ok -v -k
    6. Configure a resolução DNS para o endpoint: 
      echo 'APIGEE_ELB_EXTERNAL_IP apigeetest.com' | sudo tee -a /etc/hosts

      Em que APIGEE_ELB_EXTERNAL_IP é o endereço IP externo do serviço apigee-elb obtido em uma etapa anterior.

    7. Acesse https://apigeetest.com/ok em um navegador da Web e confirme se ele funciona.

    Configurar o TLS para a interface do usuário do Edge

    Para configurar o TLS na interface do Edge:

    1. Gere um arquivo de keystore com o arquivo de certificado SSL e o arquivo de chave: 
      openssl pkcs12 -export -clcerts -in server.crt -inkey server.key -out keystore.pkcs12
keytool -importkeystore -srckeystore keystore.pkcs12 -srcstoretype pkcs12 -destkeystore keystore.jks -deststoretype jks
    2. Coloque o arquivo de keystore na pasta do Apigee em node1: 
      scp -i SSH_PRIVATE_KEY_FILE keystore.jks admin@APIGEE_NODE1_EXTERNAL_IP:/home/admin/

      Em que:

      • SSH_PRIVATE_KEY_FILE é o nome do arquivo que contém a chave privada SSH do nó do Apigee.
      • APIGEE_NODE1_EXTERNAL_IP é o endereço IP externo do node1 do Apigee obtido em uma etapa anterior.

    3. Use SSH para acessar node1 e mova o arquivo do keystore para a pasta do Apigee: 
      sudo mv keystore.jks /opt/apigee/customer/application/
    4. Crie o arquivo de configuração SSL: 
      sudo vi /tmp/sslConfigFile
    5. Atualize o valor de KEY-PASS-PHRASE conforme mostrado: 
      HTTPSPORT=9443
DISABLE_HTTP=n
KEY_ALGO=JKS
KEY_FILE_PATH=/opt/apigee/customer/application/keystore.jks
KEY_PASS=KEY_PASS_PHRASE
    6. Configure o SSL usando o arquivo de configuração: 
      sudo chown apigee:apigee /tmp/sslConfigFile
/opt/apigee/apigee-service/bin/apigee-service edge-ui configure-ssl -f /tmp/sslConfigFile
    7. Configure a resolução de DNS para a interface do usuário do Edge: 
      echo 'APIGEE_ELB_EXTERNAL_IP ui.apigeetest.com' | sudo tee -a /etc/hosts

      Em que APIGEE_ELB_EXTERNAL_IP é o endereço IP externo do serviço apigee-elb obtido em uma etapa anterior.

    8. Acesse https://ui.apigeetest.com:9443 em um navegador da Web e confirme se ele funciona. Para mais detalhes, consulte o guia.

    Configurar o TLS para a API Management

    Para configurar o TLS para a API Management:

    1. Configure o proprietário do arquivo de keystore (use o mesmo da interface do Edge): 
      sudo chown apigee:apigee /opt/apigee/customer/application/keystore.jks
    2. Crie o arquivo de propriedades: 
      sudo vi /opt/apigee/customer/application/management-server.properties

      3. Substitua o valor de KEY_PASS_PHRASE pela senha do keystore, conforme mostrado: 

      conf_webserver_ssl.enabled=true
# Leave conf_webserver_http.turn.off set to false
# because many Edge internal calls use HTTP.
conf_webserver_http.turn.off=false
conf_webserver_ssl.port=8443
conf_webserver_keystore.path=/opt/apigee/customer/application/keystore.jks
# Enter the obfuscated keystore password below.
conf_webserver_keystore.password=KEY_PASS_PHRASE
    3. Reinicie o servidor de gerenciamento para que as mudanças entrem em vigor: 
      /opt/apigee/apigee-service/bin/apigee-service edge-management-server restart
    4. Confirme se o HTTPS funciona localmente: 
      curl -u "opdk@apigee.com:Apigee123!" "https://localhost:8443/v1/users" -k
    5. No cliente, acesse https://apigeetest.com:8443/v1/users no navegador. Digite o nome de usuário e a senha do administrador para confirmar se as credenciais estão configuradas corretamente.

    A seguir