Como instalar e gerenciar a Apigee híbrida com gráficos do Helm

Neste documento, orientamos você no processo passo a passo de instalação da Apigee híbrida v1.10 usando gráficos do Helm.

Versão

Os gráficos Helm da Apigee híbrida são para uso com a Apigee híbrida v1.10.x. Consulte o histórico de versões da Apigee híbrida para conferir a lista de versões híbridas.

Pré-requisitos

• Apigee híbrida 1.10.5
• Helm v3.10+
• Acesso ao repositório de gráficos do Helm da Apigee híbrida em:
  oci://us-docker.pkg.dev/apigee-release/apigee-hybrid-helm-charts
• CLI gcloud
• Um projeto do Google Cloud para sua instalação da Apigee híbrida. Consulte Como criar e gerenciar projetos.
• Um cluster do Kubernetes para sua instalação da Apigee híbrida. Confira:
  • Plataforma e versão do Kubernetes compatíveis
  • Configurações mínimas do cluster

Escopo

• Essa versão é compatível apenas com a Apigee híbrida versão 1.10.5.
• Essa versão é compatível com:
  • Novas instalações da Apigee híbrida.
  • As instalações da Apigee híbrida foram atualizadas para a versão 1.10.5 e migraram para o gerenciamento do Helm usando a ferramenta de migração Apigee híbrida Helm.
• Essa versão é compatível com:
  • Instalação básica da Apigee híbrida
  • Backup e restauração do Cassandra
  • Configuração multirregional

Plataformas e versões compatíveis do Kubernetes

Limitações

• Os gráficos do Helm não são totalmente compatíveis com CRDs. Portanto, usaremos o comando kubectl -k para instalá-los e fazer upgrade deles. Nosso objetivo é seguir as práticas recomendadas da comunidade e do Google em relação ao gerenciamento do Kubernetes. As implantações de CRD com o Helm ainda não atingiram um estado de comunidade em que vemos um amplo suporte ou solicitações para esse modelo. Portanto, o gerenciamento de CRDs da Apigee precisa ser feito usando kubectl, conforme mencionado neste documento.
• Em apigeectl, usamos arquivos em overrides.yaml para contas de serviço e certificados; No entanto, o Helm não aceita referenciar arquivos fora do diretório do gráfico. Escolha uma das seguintes opções para a conta de serviço e os arquivos de certificado:
  • Coloque cópias de arquivos relevantes dentro de cada diretório de gráfico
  • Crie links simbólicos dentro de cada diretório de gráfico para cada arquivo ou uma pasta. O Helm seguirá links simbólicos fora do diretório do gráfico, mas gerará um aviso como este:
    apigee-operator/gsa -> ../gsa
  • Use secrets do Kubernetes. Por exemplo, para contas de serviço:

    kubectl create secret generic SECRET_NAME \
      --from-file="client_secret.json=CLOUD_IAM_FILE_NAME.json" \
      -n apigee
    

    Substitua:
    • SECRET_NAME pelo nome do secret do Kubernetes que você criou.
    • CLOUD_IAM_FILE_NAME.json com o nome do arquivo JSON salvo.

Plataforma e versões compatíveis do Kubernetes

Para uma lista de plataformas suportadas, consulte a coluna v1.10 na tabela de plataformas suportadas da Apigee híbrida.

Permissões necessárias

Nesta tabela, listamos os recursos e permissões necessários para o Kubernetes e a Apigee.

Para filtrar essa tabela, realize uma ou mais destas ações: selecione uma categoria, digite um termo de pesquisa ou clique no cabeçalho de uma coluna para classificar.

Consulte também:

• Como usar a autorização do RBAC
• Determinar o verbo da solicitação

Preparar para a instalação

Os gráficos da Apigee híbrida são hospedados no Google Artifact Registry:

oci://us-docker.pkg.dev/apigee-release/apigee-hybrid-helm-charts

Extrair gráficos do Apigee Helm

Usando o comando pull, copie todos os gráficos da Apigee híbrida do Helm para o armazenamento local com o seguinte comando:

export CHART_REPO=oci://us-docker.pkg.dev/apigee-release/apigee-hybrid-helm-charts
export CHART_VERSION=1.10.5
helm pull $CHART_REPO/apigee-operator --version $CHART_VERSION --untar
helm pull $CHART_REPO/apigee-datastore --version $CHART_VERSION --untar
helm pull $CHART_REPO/apigee-env --version $CHART_VERSION --untar
helm pull $CHART_REPO/apigee-ingress-manager --version $CHART_VERSION --untar
helm pull $CHART_REPO/apigee-org --version $CHART_VERSION --untar
helm pull $CHART_REPO/apigee-redis --version $CHART_VERSION --untar
helm pull $CHART_REPO/apigee-telemetry --version $CHART_VERSION --untar
helm pull $CHART_REPO/apigee-virtualhost --version $CHART_VERSION --untar

Instalar a Apigee híbrida

Visão geral da sequência de instalação

A instalação dos componentes é feita da esquerda para a direita, em sequência, como mostrado na figura a seguir. Os componentes empilhados verticalmente na figura podem ser instalados juntos e em qualquer ordem. Depois de instalar qualquer componente, você poderá atualizá-lo individualmente e a qualquer momento. Por exemplo, réplica, memória, CPU e assim por diante.

Prepare-se para instalar a Apigee híbrida com gráficos do Helm

1. Crie o namespace que será usado para recursos apigee. Ele precisa corresponder ao campo de namespace no arquivo overrides.yaml. Se não estiver presente em overrides.yaml, o padrão será apigee.

   1. Verifique se o namespace já existe:

      kubectl get namespace apigee

      Se o namespace existir, a saída incluirá:

        NAME     STATUS   AGE
        apigee   Active   1d

   2. Se o namespace ainda não existir, crie-o:

      kubectl create namespace apigee

2. Crie o namespace apigee-system usado pelos recursos do operador da Apigee.

   1. Verifique se o namespace já existe:

      kubectl get namespace apigee-system

   2. Se o namespace ainda não existir, crie-o:

      kubectl create namespace apigee-system

3. Crie as contas de serviço e atribua os papéis do IAM apropriados a elas. A Apigee híbrida usa as seguintes contas de serviço:

   Conta de serviço	Papéis do IAM
   apigee-cassandra	Administrador de objetos do Storage
   apigee-logger	Gravador de registros
   apigee-mart	Agente do Apigee Connect
   apigee-metrics	Gravador de métricas do Monitoring
   apigee-runtime	Nenhum papel necessário
   apigee-synchronizer	Gerenciador de sincronização da Apigee
   apigee-udca	Agente de análise da Apigee
   apigee-watcher	Agente do ambiente de execução da Apigee

   A Apigee fornece uma ferramenta, create-service-account, no diretório apigee-operator/etc/tools:

   APIGEE_HELM_CHARTS_HOME/
   └── apigee-operator/
       └── etc/
           └── tools/
               └── create-service-account
   

   Essa ferramenta cria as contas de serviço, atribui os papéis do IAM a cada uma delas e faz o download dos arquivos de certificado no formato JSON para cada uma delas.

   1. Crie o diretório em que você quer fazer o download dos arquivos de certificado da conta de serviço. Você especificará isso no comando a seguir, no lugar de SERVICE_ACCOUNTS_PATH.
   2. É possível criar todas as contas de serviço com um único comando com as seguintes opções:

      APIGEE_HELM_CHARTS_HOME/apigee-operator/etc/tools/create-service-account --env prod --dir SERVICE_ACCOUNTS_PATH
      

   3. Liste os nomes das contas de serviço para o arquivo de substituições:

      ls service-accounts
      

      my_project-apigee-cassandra.json    my_project-apigee-runtime.json
      my_project-apigee-logger.json       my_project-apigee-synchronizer.json
      my_project-apigee-mart.json         my_project-apigee-udca.json
      my_project-apigee-metrics.json      my_project-apigee-watcher.json

      Para mais informações, veja:

      • Etapa 4: criar contas de serviço
      • Sobre contas de serviço
4. Antes da instalação, confira o arquivo overrides.yaml para verificar as configurações:

   instanceID: UNIQUE_ID_TO_IDENTIFY_THIS_CLUSTER
   namespace: apigee # required for Helm charts installation
   
   # By default, logger and metrics are enabled and requires below details
   # Google Cloud project and cluster
   gcp:
     projectID: PROJECT_ID
     region: REGION
   
   k8sCluster:
     name: CLUSTER_NAME
     region: REGION
   
   org: ORG_NAME
   
   envs:
   - name: "ENV_NAME"
     serviceAccountPaths:
       runtime: "PATH_TO_RUNTIME_SVC_ACCOUNT"
       synchronizer: "PATH_TO_SYNCHRONIZER_SVC_ACCOUNT"
       udca: "PATH_TO_UDCA_SVC_ACCOUNT"
   
   ingressGateways:
   - name: GATEWAY_NAME # maximum 17 characters, eg: "ingress-1". See Known issue 243167389.
     replicaCountMin: 1
     replicaCountMax: 2
     svcType: LoadBalancer
   
   virtualhosts:
   - name: ENV_GROUP_NAME
     selector:
       app: apigee-ingressgateway
       ingress_name: GATEWAY_NAME
     sslSecret: SECRET_NAME
   
   mart:
     serviceAccountPath: "PATH_TO_MART_SVC_ACCOUNT"
   
   logger:
     enabled: TRUE_FALSE # lowercase without quotes, eg: true
     serviceAccountPath: "PATH_TO_LOGGER_SVC_ACCOUNT"
   
   metrics:
     enabled: TRUE_FALSE # lowercase without quotes, eg: true
     serviceAccountPath: "PATH_TO_METRICS_SVC_ACCOUNT"
   
   udca:
     serviceAccountPath: "PATH_TO_UDCA_SVC_ACCOUNT"
   
   connectAgent:
     serviceAccountPath: "PATH_TO_MART_SVC_ACCOUNT"
   
   watcher:
     serviceAccountPath: "PATH_TO_WATCHER_SVC_ACCOUNT"

   Esta é a mesma configuração de substituição que você usará para esta instalação do Helm. Para mais configurações, consulte a Referência da propriedade de configuração.

   Para mais exemplos de arquivos de substituição, consulte a Etapa 6: configurar o ambiente de execução híbrido.

5. Ativar acesso do Synchronizer Esse é um pré-requisito para instalar a Apigee híbrida.

   1. Verifique se o acesso ao sincronizador já está ativado com os seguintes comandos:

      export TOKEN=$(gcloud auth print-access-token)
      

      curl -X POST -H "Authorization: Bearer $TOKEN" \
        -H "Content-Type:application/json" \
        "https://apigee.googleapis.com/v1/organizations/ORG_NAME:getSyncAuthorization" \
        -d ''
      

      A resposta será semelhante a esta:

      {
        "identities":[
           "serviceAccount:SYNCHRONIZER_SERVICE_ACCOUNT_ID"
        ],
        "etag":"BwWJgyS8I4w="
      }

   2. Se a saída não incluir o ID da conta de serviço, ative o acesso do sincronizador. Sua conta precisa ter o papel do IAM de Administrador da organização da Apigee (roles/apigee.admin) para executar essa tarefa.

      curl -X POST -H "Authorization: Bearer $TOKEN" \
        -H "Content-Type:application/json" \
        "https://apigee.googleapis.com/v1/organizations/ORG_NAME:setSyncAuthorization" \
        -d '{"identities":["'"serviceAccount:SYNCHRONIZER_SERVICE_ACCOUNT_ID"'"]}'
      

      Consulte a Etapa 7: ativar o acesso do sincronizador na documentação de instalação da Apigee híbrida para informações mais detalhadas.

6. Instale o Cert Manager com o seguinte comando:

   kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.11.1/cert-manager.yaml
   

7. Instale os CRDs da Apigee:

   1. Use o recurso de simulação kubectl executando o seguinte comando:

      kubectl apply -k  apigee-operator/etc/crds/default/ --server-side --force-conflicts --validate=false --dry-run=server
      

   2. Depois de validar com o comando de simulação, execute o seguinte:

      kubectl apply -k  apigee-operator/etc/crds/default/ --server-side --force-conflicts --validate=false
      

   3. Valide a instalação com o comando kubectl get crds:

      kubectl get crds | grep apigee

      A resposta será semelhante a esta:

      apigeedatastores.apigee.cloud.google.com                    2023-10-09T14:48:30Z
      apigeedeployments.apigee.cloud.google.com                   2023-10-09T14:48:30Z
      apigeeenvironments.apigee.cloud.google.com                  2023-10-09T14:48:31Z
      apigeeissues.apigee.cloud.google.com                        2023-10-09T14:48:31Z
      apigeeorganizations.apigee.cloud.google.com                 2023-10-09T14:48:32Z
      apigeeredis.apigee.cloud.google.com                         2023-10-09T14:48:33Z
      apigeerouteconfigs.apigee.cloud.google.com                  2023-10-09T14:48:33Z
      apigeeroutes.apigee.cloud.google.com                        2023-10-09T14:48:33Z
      apigeetelemetries.apigee.cloud.google.com                   2023-10-09T14:48:34Z
      cassandradatareplications.apigee.cloud.google.com           2023-10-09T14:48:35Z
      

8. Verifique os identificadores nos nós do cluster. Por padrão, a Apigee programa pods de dados em nós com o rótulo cloud.google.com/gke-nodepool=apigee-data e os pods de ambiente de execução são programados em nós com o rótulo cloud.google.com/gke-nodepool=apigee-runtime. É possível personalizar os rótulos do pool de nós no arquivo overrides.yaml.

   Para mais informações, consulte Como configurar pools de nós dedicados.

Instalar os gráficos do Helm da Apigee híbrida

1. Instale o operador/controlador da Apigee:

   helm upgrade operator apigee-operator/ \
     --install \
     --namespace apigee-system \
     --atomic \
     -f overrides.yaml
   

   Verifique a instalação do operador da Apigee:

   helm ls -n apigee-system
   

   NAME           NAMESPACE       REVISION        UPDATED                                 STATUS          CHART                   APP VERSION
   operator    apigee-system   3               2023-06-26 00:42:44.492009 -0800 PST    deployed        apigee-operator-1.10.5   1.10.5

   Para saber se ele está funcionando, confira a disponibilidade:

   kubectl -n apigee-system get deploy apigee-controller-manager
   

   NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
   apigee-controller-manager   1/1     1            1           7d20h

2. Instale o repositório de dados da Apigee:

   helm upgrade datastore apigee-datastore/ \
     --install \
     --namespace apigee \
     --atomic \
     -f overrides.yaml
   

   Para saber se o apigeedatastore está em execução, confira o estado dele:

   kubectl -n apigee get apigeedatastore default
   

   NAME      STATE       AGE
   default   running    2d

3. Instale a telemetria da Apigee:

   helm upgrade telemetry apigee-telemetry/ \
     --install \
     --namespace apigee \
     --atomic \
     -f overrides.yaml
   

   Para saber se ele está funcionando, confira o estado dele:

   kubectl -n apigee get apigeetelemetry apigee-telemetry
   

   NAME               STATE     AGE
   apigee-telemetry   running   2d

4. Instale o Apigee Redis:

   helm upgrade redis apigee-redis/ \
     --install \
     --namespace apigee \
     --atomic \
     -f overrides.yaml
   

   Para saber se ele está funcionando, confira o estado dele:

   kubectl -n apigee get apigeeredis default
   

   NAME      STATE     AGE
   default   running   2d

5. Instale o gerenciador de entrada da Apigee:

   helm upgrade ingress-manager apigee-ingress-manager/ \
     --install \
     --namespace apigee \
     --atomic \
     -f overrides.yaml
   

   Para saber se ele está funcionando, confira a disponibilidade:

   kubectl -n apigee get deployment apigee-ingressgateway-manager
   

   NAME                            READY   UP-TO-DATE   AVAILABLE   AGE
   apigee-ingressgateway-manager   2/2     2            2           2d

6. Instale a organização da Apigee:

   helm upgrade ORG_NAME apigee-org/ \
     --install \
     --namespace apigee \
     --atomic \
     -f overrides.yaml
   

   Para saber se ele está funcionando, confira o estado da respectiva organização:

   kubectl -n apigee get apigeeorg
   

   NAME                      STATE     AGE
   apigee-org1-xxxxx          running   2d

7. Instale o ambiente.

   É preciso instalar um ambiente de cada vez. Especifique o ambiente com --set env=ENV_NAME:

   helm upgrade apigee-env-ENV_NAME apigee-env/ \
     --install \
     --namespace apigee \
     --atomic \
     --set env=ENV_NAME \
     -f overrides.yaml
   

   Para saber se ele está funcionando, confira o estado do respectivo ambiente:

   kubectl -n apigee get apigeeenv
   

   NAME                          STATE       AGE   GATEWAYTYPE
   apigee-org1-dev-xxx            running     2d

8. Crie os certificados TLS. É necessário fornecer certificados TLS para o gateway de entrada do ambiente de execução na configuração do Apigee Hybrid.

   1. Crie os certificados. Em um ambiente de produção, será necessário usar certificados assinados. É possível usar um certificado e um par de chaves ou um secret do Kubernetes.

      Para instalação de demonstração e teste, o gateway de ambiente de execução pode aceitar credenciais autoassinados. No exemplo a seguir, openssl é usado para gerar as credenciais autoassinadas:

      openssl req -nodes -new -x509 \
        -keyout PATH_TO_CERTS_DIRECTORY/keystore_ENV_GROUP_NAME.key \
        -out PATH_TO_CERTS_DIRECTORY/keystore_ENV_GROUP_NAME.pem \
        -subj '/CN='YOUR_DOMAIN'' -days 3650
      

      Veja mais informações na Etapa 5: criar certificados TLS.

   2. Crie o secret do Kubernetes para fazer referência aos certificados:

      kubectl create secret generic NAME \
        --from-file="cert=PATH_TO_CRT_FILE" \
        --from-file="key=PATH_TO_KEY_FILE" \
        -n apigee
      

9. Instalar o host virtual.

   É necessário instalar um grupo de ambiente (virtualhost) por vez. Especifique o grupo de ambientes com --set envgroup=ENV_GROUP_NAME:

   # repeat the following command for each env group mentioned in the overrides.yaml file
   helm upgrade apigee-virtualhost-ENV_GROUP_NAME apigee-virtualhost/ \
     --install \
     --namespace apigee \
     --atomic \
     --set envgroup=ENV_GROUP_NAME \
     -f overrides.yaml
   

   Isso cria a ApigeeRouteConfig (ARC), que cria internamente a ApigeeRoute (AR) depois que o inspetor da Apigee extrai detalhes relacionados ao grupo de ambiente do plano de controle. Portanto, verifique se o estado de RA correspondente está em execução:

   kubectl -n apigee get arc
   

   NAME                                STATE   AGE
   apigee-org1-dev-egroup                       2d

   kubectl -n apigee get ar
   

   NAME                                        STATE     AGE
   apigee-org1-dev-egroup-xxxxxx                running   2d

Outros casos de uso para gráficos do Helm com a Apigee híbrida

Backup e restauração do Cassandra

1. Para ativar o backup:

   1. Atualize os detalhes do backup do Cassandra no arquivo overrides.yaml:

      cassandra:
        backup:
          enabled: true
          serviceAccountPath: PATH_TO_GSA_FILE
          dbStorageBucket: BUCKET_LINK
          schedule: "45 23 * * 6"

   2. Execute o upgrade do Helm no gráfico apigee-datastore:

      helm upgrade datastore apigee-datastore/ \
        --namespace apigee \
        --atomic \
        -f overrides.yaml
      

2. Da mesma forma, para ativar a restauração:

   1. Atualize os detalhes da restauração do Cassandra no arquivo overrides.yaml:

      cassandra:
        restore:
          enabled: true
          snapshotTimestamp: TIMESTAMP
          serviceAccountPath: PATH_TO_GSA_FILE
          cloudProvider: "CSI"

   2. Execute o upgrade do Helm no gráfico apigee-datastore:

      helm upgrade datastore apigee-datastore/ \
        --namespace apigee \
        --atomic \
        -f overrides.yaml
      

Consulte Visão geral do backup do Cassandra para ver mais detalhes sobre o backup e a restauração do Cassandra.

Expansão multirregional

A configuração multirregional com gráficos Helm requer os mesmos pré-requisitos dos procedimentos apigeectl atuais. Para mais detalhes, consulte Pré-requisitos para implantações multirregionais.

O procedimento para configurar o híbrido para multirregiões é o mesmo que o atual no processo de configuração do host de semente multirregional e do cluster e do contexto do Kubernetes.

Configurar a primeira região

Siga as etapas abaixo para configurar a primeira região e se preparar para a configuração da segunda:

1. Siga as etapas em Configurar a Apigee híbrida para várias regiões e configure o host de semente multirregional na sua plataforma.

2. Para a primeira região criada, acesse os pods no namespace da Apigee:

   kubectl get pods -o wide -n apigee
   

3. Identifique o endereço do host de semente multirregional para Cassandra nesta região, por exemplo, 10.0.0.11.

4. Prepare o arquivo overrides.yaml para a segunda região e adicione o endereço IP do host de semente da seguinte maneira:

   cassandra:
     multiRegionSeedHost: "SEED_HOST_IP_ADDRESS"
     datacenter: "DATACENTER_NAME"
     rack: "RACK_NAME"
     clusterName: CLUSTER_NAME
     hostNetwork: false

   Substitua:

   • SEED_HOST_IP_ADDRESS pelo endereço IP do host de semente, por exemplo, 10.0.0.11.
   • DATACENTER_NAME pelo nome do data center. Por exemplo, dc-2.
   • RACK_NAME pelo nome do rack, por exemplo, ra-1.
   • CLUSTER_NAME pelo nome do cluster da Apigee. Por padrão, o valor é apigeecluster. Se você usar um nome de cluster diferente, será preciso especificar um valor para cassandra.clusterName. Esse valor precisa ser o mesmo em todas as regiões.

Configurar a segunda região

Para configurar a nova região:

1. Instale cert-manager na região 2:

   kubectl apply -f https://github.com/cert-manager/cert-manager/releases/download/v1.11.1/cert-manager.yaml
   

2. Copie o certificado do cluster atual para o novo cluster. A nova raiz da CA é usada pelo Cassandra e outros componentes híbridos para mTLS. Portanto, é essencial ter certificados consistentes em todo o cluster.

   1. Defina o contexto como o namespace original:

      kubectl config use-context ORIGINAL_CLUSTER_NAME
      

   2. Exporte a configuração atual do namespace para um arquivo:

      kubectl get namespace apigee -o yaml > apigee-namespace.yaml
      

   3. Exporte o secret apigee-ca para um arquivo:

      kubectl -n cert-manager get secret apigee-ca -o yaml > apigee-ca.yaml
      

   4. Defina o contexto para o nome do cluster da nova região

      kubectl config use-context NEW_CLUSTER_NAME
      

   5. Importe a configuração do namespace para o novo cluster. Atualize o namespace no arquivo se estiver usando um namespace diferente na nova região:

      kubectl apply -f apigee-namespace.yaml
      

   6. Importe o secret para o novo cluster:

      kubectl -n cert-manager apply -f apigee-ca.yaml
      

3. Agora use gráficos do Helm para instalar a Apigee híbrida na nova região com os seguintes comandos do gráfico do Helm (como feito na região 1):

   helm upgrade operator apigee-operator \
     --install \
     --namespace apigee-system \
     --atomic
     -f overrides-DATACENTER_NAME.yaml
   helm upgrade datastore apigee-datastore \
     --install \
     --namespace apigee \
     --atomic \
     -f overrides-DATACENTER_NAME.yaml
   helm upgrade telemetry apigee-telemetry \
     --install \
     --namespace apigee \
     --atomic \
     -f overrides-DATACENTER_NAME.yaml
   helm upgrade redis apigee-redis \
     --install \
     --namespace apigee \
     --atomic \
     -f overrides-DATACENTER_NAME.yaml
   helm upgrade ingress-manager apigee-ingress-manager \
     --install \
     --namespace apigee \
     --atomic \
     -f overrides-DATACENTER_NAME.yaml
   helm upgrade ORG_NAME apigee-org \
     --install \
     --namespace apigee \
     --atomic \
     -f overrides-DATACENTER_NAME.yaml
   # repeat the below command for each env mentioned on the overrides
   helm upgrade apigee-env-ENV_NAME apigee-env/ \
     --install \
     --namespace apigee \
     --atomic \
     --set env=ENV_NAME \
     -f overrides-DATACENTER_NAME.yaml
   # repeat the below command for each env group mentioned on the overrides
   helm upgrade apigee-virtualhost-ENV_GROUP_NAME apigee-virtualhost/ \
     --install \
     --namespace apigee \
     --atomic \
     --set envgroup=ENV_GROUP_NAME \
     -f overrides-DATACENTER_NAME.yaml
   

4. Depois que todos os componentes estiverem instalados, configure o Cassandra em todos os pods nos novos data centers. Para instruções, consulte Configurar a Apigee híbrida para várias regiões, selecione a plataforma, role até Configurar a nova região e localize a etapa 5.
5. Depois que a replicação de dados for concluída e verificada, atualize os hosts de origem:
   1. Remova multiRegionSeedHost: 10.0.0.11 de overrides-DATACENTER_NAME.yaml

      A entrada multiRegionSeedHost não é mais necessária depois que a replicação de dados é estabelecida e espera-se que os IPs de pod mudem com o tempo.

   2. Reaplique a alteração para atualizar a resposta automática do repositório de dados da Apigee:

      helm upgrade datastore apigee-datastore/ \
        --install \
        --namespace apigee \
        --atomic \
        -f overrides-DATACENTER_NAME.yaml
      

Hospedar imagens de maneira particular

Em vez de depender do repositório público do Google Cloud, talvez você queira hospedar as imagens de maneira particular. Em vez de substituir cada componente, adicione detalhes do hub nas substituições:

hub: PRIVATE_REPO

Por exemplo, se o hub a seguir for fornecido, ele resolverá automaticamente o caminho da imagem:

hub: private-docker-host.com

como:

## an example of internal component vs 3rd party
containers:
- name: apigee-udca
  image: private-docker-host.com/apigee-udca:1.10.5
  imagePullPolicy: IfNotPresent

containers:
- name: apigee-ingressgateway
  image: private-docker-host.com/apigee-asm-ingress:1.17.2-asm.8-distroless
  imagePullPolicy: IfNotPresent

apigee:
  gcr.io/apigee-release/hybrid/apigee-mart-server:1.10.3
  gcr.io/apigee-release/hybrid/apigee-synchronizer:1.10.3
  gcr.io/apigee-release/hybrid/apigee-runtime:1.10.3
  gcr.io/apigee-release/hybrid/apigee-hybrid-cassandra-client:1.10.3
  gcr.io/apigee-release/hybrid/apigee-hybrid-cassandra:1.10.3
  gcr.io/apigee-release/hybrid/apigee-cassandra-backup-utility:1.10.3
  gcr.io/apigee-release/hybrid/apigee-udca:1.10.3
  gcr.io/apigee-release/hybrid/apigee-connect-agent:1.10.3
  gcr.io/apigee-release/hybrid/apigee-watcher:1.10.3
  gcr.io/apigee-release/hybrid/apigee-operators:1.10.3
  gcr.io/apigee-release/hybrid/apigee-redis:1.10.3
  gcr.io/apigee-release/hybrid/apigee-mint-task-scheduler:1.10.3

third party:
  gcr.io/apigee-release/hybrid/apigee-stackdriver-logging-agent:1.9.12-2
  gcr.io/apigee-release/hybrid/apigee-prom-prometheus:v2.45.0
  gcr.io/apigee-release/hybrid/apigee-stackdriver-prometheus-sidecar:0.9.0
  gcr.io/apigee-release/hybrid/apigee-kube-rbac-proxy:v0.14.2
  gcr.io/apigee-release/hybrid/apigee-envoy:v1.27.0
  gcr.io/apigee-release/hybrid/apigee-prometheus-adapter:v0.11.0
  gcr.io/apigee-release/hybrid/apigee-asm-ingress:1.17.2-asm.8-distroless
  gcr.io/apigee-release/hybrid/apigee-asm-istiod:1.17.2-asm.8-distroless
  gcr.io/apigee-release/hybrid/apigee-fluent-bit:2.1.8

Para exibir uma lista das imagens da Apigee hospedadas no repositório do Google Cloud na linha de comando:

./apigee-operator/etc/tools/apigee-pull-push.sh --list

Tolerâncias

Para usar o recurso de taints e tolerâncias do Kubernetes, é necessário definir a propriedade de substituição tolerations para cada componente da Apigee híbrida. Os seguintes componentes são compatíveis com a definição de tolerâncias:

• ao
• apigeeIngressGateway
• cassandra
• cassandraSchemaSetup
• cassandraSchemaValidation
• cassandraUserSetup
• connectAgent
• istiod
• logger
• mart
• metrics
• mintTaskScheduler
• redis
• runtime
• synchronizer
• udca
• Watcher

Consulte a Referência da propriedade de configuração para mais informações sobre esses componentes.

Por exemplo, para aplicar as tolerâncias à implantação do operador da Apigee:

ao:
  tolerations:
  - key: "key1"
    operator: "Equal"
    value: "value1"
    effect: "NoExecute"
    tolerationSeconds: 3600

Para aplicar as tolerâncias ao StatefulSet do Cassandra:

cassandra:
  tolerations:
  - key: "key1"
    operator: "Equal"
    value: "value1"
    effect: "NoExecute"
    tolerationSeconds: 3600

Desinstalar a Apigee híbrida com o Helm

Para desinstalar uma atualização ou versão específica, use o comando helm [uninstall/delete] RELEASE-NAME -n NAMESPACE.

Use as etapas a seguir para desinstalar completamente a Apigee híbrida do cluster:

1. Exclua os virtualhosts. Execute este comando para cada host virtual:

   helm -n apigee delete VIRTUALHOST_RELEASE-NAME
   

2. Exclua os ambientes. Execute este comando para cada ambiente:

   helm -n apigee delete ENV_RELEASE-NAME
   

3. Exclua a organização da Apigee:

   helm -n apigee delete ORG_RELEASE-NAME
   

4. excluir telemetria:

   helm -n apigee delete TELEMETRY_RELEASE-NAME
   

5. Exclua o Redis:

   helm -n apigee delete REDIS_RELEASE-NAME
   

6. Exclua o gerenciador de entrada:

   helm -n apigee delete INGRESS_MANAGER_RELEASE-NAME
   

7. Excluir o repositório de dados:

   helm -n apigee delete DATASTORE_RELEASE-NAME
   

8. Excluir o operador.
   1. Verifique se todas as respostas automáticas foram excluídas antes de:

      kubectl -n apigee get apigeeds, apigeetelemetry, apigeeorg, apigreeenv, arc, apigeeredis
      

   2. Exclua o operador da Apigee:

      helm -n apigee-system delete OPERATOR_RELEASE-NAME
      

9. Exclua os CRDs da Apigee híbrida:

   kubectl delete -k  apigee-operator/etc/crds/default/