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

Escopo

Plataformas e versões compatíveis do Kubernetes

Plataforma Versões
GKE; 1.24, 1.25, 1.26
AKS 1.24, 1.25, 1.26
EKS 1.24, 1.25, 1.26
OpenShift 4.11, 4.12

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
      

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.

Categoria Recurso Tipo de recurso Permissões do RBAC do Kubernetes
Datastore apigeedatastores.apigee.cloud.google.com Apigee create delete patch update
Datastore certificates.cert-manager.io Kubernetes create delete patch update
Datastore cronjobs.batch Kubernetes create delete patch update
Datastore jobs.batch Kubernetes create delete patch update
Datastore secrets Kubernetes create delete patch update
Env apigeeenvironments.apigee.cloud.google.com Apigee create delete patch update
Env secrets Kubernetes create delete patch update
Env serviceaccounts Kubernetes create delete patch update
Administrador de entrada certificates.cert-manager.io Kubernetes create delete patch update
Administrador de entrada configmaps Kubernetes create delete patch update
Administrador de entrada deployments.apps Kubernetes create delete patch update
Administrador de entrada horizontalpodautoscalers.autoscaling Kubernetes create delete patch update
Administrador de entrada issuers.cert-manager.io Kubernetes create delete patch update
Administrador de entrada serviceaccounts Kubernetes create delete patch update
Administrador de entrada services Kubernetes create delete patch update
Operador apigeedatastores.apigee.cloud.google.com Apigee create delete get list patch update watch
Operador apigeedatastores.apigee.cloud.google.com/finalizers Apigee get patch update
Operador apigeedatastores.apigee.cloud.google.com/status Apigee get patch update
Operador apigeedeployments.apigee.cloud.google.com Apigee create delete get list patch update watch
Operador apigeedeployments.apigee.cloud.google.com/finalizers Apigee get patch update
Operador apigeedeployments.apigee.cloud.google.com/status Apigee get patch update
Operador apigeeenvironments.apigee.cloud.google.com Apigee create delete get list patch update watch
Operador apigeeenvironments.apigee.cloud.google.com/finalizers Apigee get patch update
Operador apigeeenvironments.apigee.cloud.google.com/status Apigee get patch update
Operador apigeeissues.apigee.cloud.google.com Apigee create delete get list watch
Operador apigeeorganizations.apigee.cloud.google.com Apigee create delete get list patch update watch
Operador apigeeorganizations.apigee.cloud.google.com/finalizers Apigee get patch update
Operador apigeeorganizations.apigee.cloud.google.com/status Apigee get patch update
Operador apigeeredis.apigee.cloud.google.com Apigee create delete get list patch update watch
Operador apigeeredis.apigee.cloud.google.com/finalizers Apigee get patch update
Operador apigeeredis.apigee.cloud.google.com/status Apigee get patch update
Operador apigeerouteconfigs.apigee.cloud.google.com Apigee get list
Operador apigeeroutes.apigee.cloud.google.com Apigee create delete get list patch update watch
Operador apigeeroutes.apigee.cloud.google.com/finalizers Apigee get patch update
Operador apigeeroutes.apigee.cloud.google.com/status Apigee get patch update
Operador apigeetelemetries.apigee.cloud.google.com Apigee create delete get list patch update watch
Operador apigeetelemetries.apigee.cloud.google.com/finalizers Apigee get patch update
Operador apigeetelemetries.apigee.cloud.google.com/status Apigee get list patch update
Operador cassandradatareplications.apigee.cloud.google.com Apigee get list patch update watch
Operador cassandradatareplications.apigee.cloud.google.com/finalizers Apigee get patch update
Operador cassandradatareplications.apigee.cloud.google.com/status Apigee get patch update
Operador *.networking.x.k8s.io Kubernetes get list watch
Operador apiservices.apiregistration.k8s.io Kubernetes create delete get list patch update watch
Operador certificates.cert-manager.io Kubernetes create delete get list patch update watch
Operador certificates.cert-manager.io/finalizers Kubernetes create delete get list patch update watch
Operador certificatesigningrequests.certificates.k8s.io Kubernetes create delete get update watch
Operador certificatesigningrequests.certificates.k8s.io/approval Kubernetes create delete get update watch
Operador certificatesigningrequests.certificates.k8s.io/status Kubernetes create delete get update watch
Operador clusterissuers.cert-manager.io Kubernetes create get watch
Operador clusterrolebindings.rbac.authorization.k8s.io Kubernetes create delete get list patch update watch
Operador clusterroles.rbac.authorization.k8s.io Kubernetes create delete get list patch update watch
Operador configmaps Kubernetes create delete get list patch update watch
Operador configmaps/status Kubernetes get patch update
Operador cronjobs.batch Kubernetes create delete get list patch update watch
Operador customresourcedefinitions.apiextensions.k8s.io Kubernetes get list watch
Operador daemonsets.apps Kubernetes create delete get list patch update watch
Operador deployments.apps Kubernetes get list watch
Operador deployments.extensions Kubernetes get list watch
Operador destinationrules.networking.istio.io Kubernetes create delete get list patch update watch
Operador endpoints Kubernetes get list watch
Operador endpointslices.discovery.k8s.io Kubernetes get list watch
Operador events Kubernetes create delete get list patch update watch
Operador gateways.networking.istio.io Kubernetes create delete get list patch update watch
Operador horizontalpodautoscalers.autoscaling Kubernetes create delete get list patch update watch
Operador ingressclasses.networking.k8s.io Kubernetes get list watch
Operador ingresses.networking.k8s.io/status Kubernetes all verbs
Operador issuers.cert-manager.io Kubernetes create delete get list patch update watch
Operador jobs.batch Kubernetes create delete get list patch update watch
Operador leases.coordination.k8s.io Kubernetes create get list update
Operador namespaces Kubernetes get list watch
Operador nodes Kubernetes get list watch
Operador peerauthentications.security.istio.io Kubernetes create delete get list patch update watch
Operador persistentvolumeclaims Kubernetes create delete get list patch update watch
Operador persistentvolumes Kubernetes get list watch
Operador poddisruptionbudgets.policy Kubernetes create delete get list patch update watch
Operador pods Kubernetes create delete get list patch update watch
Operador pods/exec Kubernetes create
Operador replicasets.apps Kubernetes create delete get list patch update watch
Operador replicasets.extensions Kubernetes get list watch
Operador resourcequotas Kubernetes create delete get list patch update watch
Operador rolebindings.rbac.authorization.k8s.io Kubernetes create delete get list patch update watch
Operador roles.rbac.authorization.k8s.io Kubernetes create delete get list patch update watch
Operador secrets Kubernetes batch create delete get list patch update watch
Operador securitycontextconstraints.security.openshift.io Kubernetes create get list
Operador serviceaccounts Kubernetes create delete get list patch update watch
Operador services Kubernetes batch create delete get list patch update watch
Operador signers.certificates.k8s.io Kubernetes approve
Operador statefulsets.apps Kubernetes create delete get list patch update watch
Operador subjectaccessreviews.authorization.k8s.io Kubernetes create get list
Operador tokenreviews.authentication.k8s.io Kubernetes create
Operador virtualservices.networking.istio.io Kubernetes create delete get list patch update watch
Org apigeeorganizations.apigee.cloud.google.com Apigee create delete patch update
Org secrets Kubernetes create delete patch update
Org serviceaccounts Kubernetes create delete patch update
Redis apigeeredis.apigee.cloud.google.com Apigee create delete patch update
Redis secrets Kubernetes create delete patch update
Telemetria apigeetelemetry.apigee.cloud.google.com Apigee create delete patch update
Telemetria secrets Kubernetes create delete patch update
Telemetria serviceaccounts Kubernetes create delete patch update
Host virtual apigeerouteconfigs.apigee.cloud.google.com Apigee create delete patch update
Host virtual secrets Kubernetes create delete patch update

Consulte também:

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

Sequência de instalação: gerenciador de certificados, CRDs e operador da Apigee e os componentes empilhados: redis, repositório de dados e telemetria e gerenciador de entrada, depois org e componentes empilhados: env e host virtual

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

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

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

  5. 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
    
  6. 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
      
  7. 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 \
      --create-namespace \
      --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.4   1.10.4

    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. Crie um secret do Kubernetes para sua conta de serviço.
  3. Crie um secret do Kubernetes para o certificado de entrada.
  4. 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
      
  5. 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 \
      --create-namespace \
      --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
    
  6. 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.
  7. 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
    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.4
  imagePullPolicy: IfNotPresent

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

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