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

Visualização — Installing Apigee hybrid with Helm charts

Esse recurso está sujeito aos "Termos de ofertas pré-GA" na seção "Termos de Serviço gerais" dos Termos específicos de serviço. Os recursos pré-GA estão disponíveis "no estado em que se encontram" e podem ter suporte limitado. Para mais informações, consulte as descrições da fase de lançamento.

Observação: este documento de visualização é aplicável à Apigee híbrida v1.10.x.

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.4
• 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 da gcloud
• 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.4.
• 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.4 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

Observação: para o gerenciamento de clusters da Apigee híbrida que foram iniciados com apigeectl, consulte ferramenta de migração Apigee híbrida do Helm.

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
    

    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.

Selecionar categoria Datastore Env Administrador de entrada Operador Org Redis Telemetria Host virtual

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:

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

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:

      • Etapa 4: criar contas de serviço
      • Sobre contas de serviço
3. Antes da instalação, confira o arquivo overrides.yaml para verificar as configurações:
   Importante: a Apigee híbrida v1.10.4 foi atualizada com uma versão de hotfix essencial Se quiser, aplique as definições de configuração necessárias para o hotfix diretamente no arquivo de substituição de configuração descrito nesta etapa. Se você adicionar as configurações de upgrade agora, não precisará executar mais upgrades de hotfix posteriormente. As definições de configuração do hotfix (v1.10.4-hotfix.1) estão listadas no guia de upgrade. Consulte também a nota da versão do hotfix:

   • v1.10.4-hotfix.1 híbrida

   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:

   Observação: a partir dessa etapa, todos os comandos precisam ser executados na raiz do repositório do gráfico.
   Observação: esse é o único método compatível para instalar CRDs da Apigee. Não use kubectl apply sem -k, não omita --server-side.
   Observação: essa etapa requer permissões elevadas de cluster.

   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

Observação: antes de executar qualquer um dos comandos de upgrade/instalação do Helm, use o recurso de simulação do Helm adicionando --dry-run ao final do. Consulte helm -h para listar comandos, opções e uso compatíveis.

Importante ferramenta de migração: se você migrou seu cluster para o gerenciamento do Helm com a Ferramenta de migração Apigee híbrida do Helm, você tem recursos no cluster migrado. Para evitar a exclusão acidental de recursos se o comando helm upgrade falhar, não use a flag ‑‑atomic.

Por exemplo, na primeira etapa, o comando será:

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

1. Instale o operador/controlador da Apigee:

   Observação: essa etapa requer permissões elevadas de cluster. Execute helm -h ou helm install -h para ver detalhes

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

   Importante: omita a flag ‑‑atomic para clusters migrados.

   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
   

   Importante: omita a flag ‑‑atomic para clusters migrados.

   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
   

   Importante: omita a flag ‑‑atomic para clusters migrados.

   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
   

   Importante: omita a flag ‑‑atomic para clusters migrados.

   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
   

   Importante: omita a flag ‑‑atomic para clusters migrados.

   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
   

   Importante: omita a flag ‑‑atomic para clusters migrados.

   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
   

   Importante: omita a flag ‑‑atomic para clusters migrados.

   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
   

   Importante: omita a flag ‑‑atomic para clusters migrados.
   Observação:ENV_GROUP_NAME precisa ser exclusivo no namespace apigee. Por exemplo, se você tiver um env e um envgroup prod, defina esse nome como prod-envgroup. O nome do grupo de ambientes posterior ainda precisará ser prod.

   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"

      Observação: ao usar um bucket do Cloud Storage, é necessário criar uma conta de serviço do Google Cloud apigee-cassandra-back e ter os papéis e/ou as permissões adequadas para gravar no bucket especificado em dbStorageBucket.

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

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

      Importante: omita a flag ‑‑atomic para clusters migrados.
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
      

      Importante: omita a flag ‑‑atomic para clusters migrados.

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

   Observação: é possível usar as mesmas CRDs para manter a consistência utilizando a mesma pasta em que você fez o download dos gráficos. Também é possível manter o arquivo de modificações exclusivo entre nas regiões 1 e 2 ao nomear algo exclusivo, como overrides2.yaml etc.

   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
   

   Importante: omita a flag ‑‑atomic para clusters migrados.
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
      

      Importante: omita a flag ‑‑atomic para clusters migrados.

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

Clique para abrir uma lista de imagens da Apigee

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