Instalar e gerir o Apigee Hybrid com gráficos Helm

Pré-visualização — Installing Apigee hybrid with Helm charts

Esta funcionalidade está sujeita aos "Termos das Ofertas de Pré-DG" na secção Termos Gerais de Serviço dos Termos Específicos do Serviço. As funcionalidades de pré-DG estão disponíveis "tal como estão" e podem ter apoio técnico limitado. Para mais informações, consulte as descrições das fases de lançamento.

<0x0

Este documento explica o processo passo a passo de instalação do Apigee hybrid v1.10 através de gráficos Helm.

Versão

Os gráficos Helm do Apigee Hybrid destinam-se a utilização com o Apigee Hybrid v1.10.x. Consulte o histórico de lançamentos do Apigee Hybrid para ver a lista de lançamentos do Hybrid.

Pré-requisitos

• Apigee Hybrid 1.10.5
• Helm v3.10 ou superior
• Acesso ao repositório de gráficos Helm do Apigee Hybrid em:
  oci://us-docker.pkg.dev/apigee-release/apigee-hybrid-helm-charts
• CLI gcloud
• Um Google Cloud projeto para a sua instalação do Apigee Hybrid. Consulte Criar e gerir projetos
• Um cluster do Kubernetes para a sua instalação do Apigee Hybrid. Veja:
  • Plataforma e versão do Kubernetes suportadas
  • Configurações mínimas do cluster

Âmbito

• Esta versão só suporta a versão 1.10.5 do Apigee Hybrid.
• Esta versão suporta:
  • Novas instalações do Apigee Hybrid.
  • Instalações híbridas do Apigee existentes atualizadas para a versão 1.10.5 e migradas para a gestão do Helm através da ferramenta de migração do Helm do Apigee hybrid.
• Esta versão suporta:
  • Instalação híbrida básica do Apigee
  • Cópia de segurança e restauro do Cassandra
  • Configuração multirregião

Nota: para a gestão de clusters híbridos do Apigee existentes que foram lançados com o apigeectl, consulte o Ferramenta de migração do Helm do Apigee hybrid.

Plataformas e versões do Kubernetes suportadas

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 Helm não suportam totalmente os CRDs. Por isso, vamos usar o comando kubectl -k para os instalar e atualizar. Procuramos seguir as práticas recomendadas da comunidade e da Google em torno da gestão do Kubernetes. As implementações de CRD através do Helm ainda não atingiram um estado de comunidade em que vemos um apoio técnico alargado ou pedidos para tal modelo. Por conseguinte, a gestão dos CRDs do Apigee deve ser feita através do kubectl, conforme mencionado neste documento.
• Em apigeectl, usámos ficheiros em todo o lado overrides.yaml para contas de serviço e certificados. No entanto, o Helm não suporta referências a ficheiros fora do diretório do gráfico. Escolha uma das seguintes opções para a conta de serviço e os ficheiros de certificado:
  • Coloque cópias dos ficheiros relevantes no diretório de cada gráfico
  • Crie links simbólicos em cada diretório de gráficos para cada ficheiro ou pasta. O Helm segue links simbólicos fora do diretório do gráfico, mas gera um aviso semelhante ao seguinte:
    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 o seguinte:
    • SECRET_NAME com o nome do segredo do Kubernetes que criou.
    • CLOUD_IAM_FILE_NAME.json com o nome do ficheiro JSON transferido.

Plataforma e versões do Kubernetes suportadas

Para ver uma lista das plataformas suportadas, consulte a coluna v1.10 na tabela de plataformas suportadas do Apigee Hybrid.

Autorizações necessárias

Esta tabela apresenta os recursos e as autorizações necessários para o Kubernetes e o Apigee.

Para filtrar esta tabela, faça uma ou mais das seguintes ações: selecione uma categoria, escreva um termo de pesquisa ou clique no cabeçalho de uma coluna para ordenar.

Selecionar categoria Armazenamento de dados Env Gestor de entrada Operador Unidade Redis Telemetria Anfitrião virtual

Categoria	Recurso	Tipo do recurso	Autorizações de RBAC do Kubernetes
Armazenamento de dados	apigeedatastores.apigee.cloud.google.com	Apigee	create delete patch update
Armazenamento de dados	certificates.cert-manager.io	Kubernetes	create delete patch update
Armazenamento de dados	cronjobs.batch	Kubernetes	create delete patch update
Armazenamento de dados	jobs.batch	Kubernetes	create delete patch update
Armazenamento de dados	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
Gestor de entrada	certificates.cert-manager.io	Kubernetes	create delete patch update
Gestor de entrada	configmaps	Kubernetes	create delete patch update
Gestor de entrada	deployments.apps	Kubernetes	create get delete patch update
Gestor de entrada	horizontalpodautoscalers.autoscaling	Kubernetes	create delete patch update
Gestor de entrada	issuers.cert-manager.io	Kubernetes	create delete patch update
Gestor de entrada	serviceaccounts	Kubernetes	create delete patch update
Gestor 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	create 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
Unidade	apigeeorganizations.apigee.cloud.google.com	Apigee	create delete patch update
Unidade	secrets	Kubernetes	create delete patch update
Unidade	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
Anfitrião virtual	apigeerouteconfigs.apigee.cloud.google.com	Apigee	create delete patch update
Anfitrião virtual	secrets	Kubernetes	create delete patch update

Veja também:

• Usar a autorização RBAC
• Determine o verbo do pedido

Prepare-se para a instalação

Os gráficos do Apigee Hybrid estão alojados no Google Artifact Registry:

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

Extraia gráficos Helm do Apigee

Usando o comando pull, copie todos os gráficos Helm do Apigee hybrid para o seu 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

Instale o Apigee Hybrid

Vista geral da sequência de instalação

A instalação dos componentes é feita da esquerda para a direita em sequência, conforme mostrado na figura seguinte. Os componentes que estão organizados verticalmente na figura podem ser instalados em conjunto e em qualquer ordem. Depois de instalar qualquer componente, pode atualizá-lo individualmente e em qualquer altura; por exemplo, réplica, memória, CPU, etc.

Prepare-se para instalar o Apigee Hybrid com gráficos Helm

1. Crie o espaço de nomes que vai ser usado para os recursos apigee. Este deve corresponder ao campo do espaço de nomes no ficheiro overrides.yaml. Se este elemento não estiver presente em overrides.yaml, o valor predefinido é apigee.

   1. Verifique se o espaço de nomes já existe:

      kubectl get namespace apigee

      Se o espaço de nomes existir, a saída inclui:

        NAME     STATUS   AGE
        apigee   Active   1d

   2. Se o espaço de nomes ainda não existir, crie-o:

      kubectl create namespace apigee

2. Crie o espaço de nomes apigee-system usado pelos recursos do operador Apigee.

   1. Verifique se o espaço de nomes já existe:

      kubectl get namespace apigee-system

   2. Se o espaço de nomes ainda não existir, crie-o:

      kubectl create namespace apigee-system

3. Crie as contas de serviço e atribua-lhes as funções do IAM adequadas. O Apigee hybrid usa as seguintes contas de serviço:

   Conta de serviço	Funções de IAM
   apigee-cassandra	Administrador de objetos de armazenamento
   apigee-logger	Escritor de registos
   apigee-mart	Agente do Apigee Connect
   apigee-metrics	Escritor de métricas de monitorização
   apigee-runtime	Nenhuma função necessária
   apigee-synchronizer	Apigee Synchronizer Manager
   apigee-udca	Agente do Apigee Analytics
   apigee-watcher	Agente de runtime do Apigee

   O 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
   

   Esta ferramenta cria as contas de serviço, atribui as funções do IAM a cada conta e transfere os ficheiros de certificado no formato JSON para cada conta.

   1. Crie o diretório onde quer transferir os ficheiros de certificado da conta de serviço. Vai especificar isto no seguinte comando no lugar de SERVICE_ACCOUNTS_PATH.
   2. Pode 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. Indique os nomes das suas contas de serviço para o ficheiro 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, consulte:

      • Passo 4: crie contas de serviço
      • Acerca das contas de serviço
4. Antes da instalação, consulte o ficheiro overrides.yaml para verificar as definições:
   Importante: o Apigee hybrid v1.10.5 foi atualizado com uma versão de correção rápida crítica. Se quiser, pode aplicar as definições de configuração necessárias para a correção rápida diretamente no ficheiro de substituições de configuração descrito neste passo. Se adicionar as configurações de atualização agora, não tem de fazer mais atualizações rápidas posteriormente. As definições de configuração da correção rápida (v1.10.5-hotfix.1) estão listadas no guia de atualização. Consulte também a nota de lançamento da versão de correção rápida:

   • hybrid v1.10.5-hotfix.1

   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ções que vai usar para esta instalação do Helm. Para mais definições, consulte a referência da propriedade de configuração.

   Para mais exemplos de ficheiros de substituições, consulte o Passo 6: configure o tempo de execução híbrido.

5. Ative o acesso do sincronizador. Este é um pré-requisito para instalar o Apigee Hybrid.

   1. Verifique se o acesso do 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 ''
      

      O resultado deve ter um aspeto semelhante ao seguinte:

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

   2. Se o resultado não incluir o ID da conta de serviço, ative o acesso do sincronizador. A sua conta tem de ter a função de IAM de administrador da organização do Apigee (roles/apigee.admin) para realizar esta 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 o Passo 7: ative o acesso do sincronizador na documentação de instalação do Apigee hybrid para ver 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 do Apigee:

   Nota: a partir deste passo, todos os comandos devem ser executados na raiz do repositório do gráfico.
   Nota: este é o único método suportado para instalar CRDs do Apigee. Não use kubectl apply sem -k, não omita --server-side.
   Nota: este passo requer autorizações de cluster elevadas.

   1. Use a funcionalidade de teste de execuçã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 fazer a validação com o comando de teste, execute o seguinte comando:

      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

      O resultado deve ter um aspeto semelhante ao seguinte:

      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 as etiquetas existentes nos nós do cluster. Por predefinição, o Apigee agenda pods de dados em nós com a etiqueta cloud.google.com/gke-nodepool=apigee-data e os pods de tempo de execução são agendados em nós com a etiqueta cloud.google.com/gke-nodepool=apigee-runtime. Pode personalizar as etiquetas do conjunto de nós no ficheiro overrides.yaml.

   Para mais informações, consulte o artigo Configurar pools de nós dedicados.

Instale os gráficos Helm do Apigee Hybrid

Nota: antes de executar qualquer um dos comandos de instalação/atualização do Helm, use a funcionalidade de teste do Helm adicionando --dry-run no final do comando. Consulte helm -h para ver uma lista dos comandos, das opções e da utilização suportados.

Importante ferramenta de migração: se migrou o cluster para a gestão do Helm com a ferramenta de migração do Helm do Apigee hybrid, tem recursos existentes no cluster migrado. Para evitar a eliminação acidental de recursos se o comando helm upgrade falhar, não use a flag ‑‑atomic.

Por exemplo, no primeiro passo, o comando é:

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

1. Instale o operador/controlador do Apigee:

   Nota: este passo requer autorizações de cluster elevadas. Execute helm -h ou helm install -h para ver os detalhes

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

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

   Valide a instalação do operador do 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

   Verifique se está em funcionamento, verificando a respetiva 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 arquivo de dados do Apigee:

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

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

   Verifique se o serviço apigeedatastore está em funcionamento verificando o respetivo estado:

   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.

   Verifique se está a funcionar corretamente, verificando o respetivo estado:

   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.

   Verifique se está a funcionar corretamente, verificando o respetivo estado:

   kubectl -n apigee get apigeeredis default
   

   NAME      STATE     AGE
   default   running   2d

5. Instale o gestor de entrada do Apigee:

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

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

   Verifique se está em funcionamento, verificando a respetiva 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 do Apigee:

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

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

   Verifique se está em funcionamento consultando o estado da organização respetiva:

   kubectl -n apigee get apigeeorg
   

   NAME                      STATE     AGE
   apigee-org1-xxxxx          running   2d

7. Instale o ambiente.

   Tem de 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.

   Verifique se está em funcionamento consultando o estado do ambiente respetivo:

   kubectl -n apigee get apigeeenv
   

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

8. Crie os certificados TLS. Tem de fornecer certificados TLS para o gateway de entrada de tempo de execução na sua configuração híbrida do Apigee.

   1. Crie os certificados. Num ambiente de produção, tem de usar certificados assinados. Pode usar um par de chaves e certificados ou um segredo do Kubernetes.

      Para demonstração e teste de instalação, o gateway de tempo de execução pode aceitar credenciais autoassinadas. No exemplo seguinte, o 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
      

      Para mais informações, consulte o Passo 5: crie certificados TLS.

   2. Crie o segredo do Kubernetes para referenciar os certificados:

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

9. Instale o anfitrião virtual.

   Tem de instalar um grupo de ambientes (virtualhost) de cada 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.
   Nota: ENV_GROUP_NAME tem de ser exclusivo no espaço de nomes apigee. Por exemplo, se tiver um prod env e envgroup, deve definir este nome como prod-envgroup. O nome do grupo de ambiente posterior deve continuar a ser prod.

   Isto cria um ApigeeRouteConfig (ARC) que cria internamente um ApigeeRoute (AR) assim que o observador do Apigee extrai detalhes relacionados com o grupo de ambientes do plano de controlo. Por conseguinte, verifique se o estado do AR 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

Exemplos de utilização adicionais de gráficos Helm com o Apigee Hybrid

Cópia de segurança e restauro do Cassandra

1. Para ativar a cópia de segurança:

   1. Atualize os detalhes da cópia de segurança do Cassandra no ficheiro overrides.yaml:

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

      Nota: quando usar um contentor do Cloud Storage, tem de criar uma Google Cloud conta de serviço apigee-cassandra-back e esta tem de ter funções e/ou autorizações adequadas para escrever no contentor especificado em dbStorageBucket.

   2. Execute a atualização 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 o restauro:

   1. Atualize os detalhes de restauro do Cassandra no ficheiro overrides.yaml:

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

   2. Execute a atualização 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 a vista geral da cópia de segurança do Cassandra para ver mais detalhes sobre a cópia de segurança e o restauro do Cassandra.

Expansão para várias regiões

A configuração multirregião com gráficos Helm requer os mesmos pré-requisitos que os procedimentos apigeectl atuais. Para ver detalhes, consulte os Pré-requisitos para implementações multirregionais.

O procedimento para configurar o modo híbrido para várias regiões é o mesmo que o procedimento existente até ao processo de configuração do anfitrião principal de várias regiões e configuração do cluster e do contexto do Kubernetes.

Configure a primeira região

Siga estes passos para configurar a primeira região e preparar-se para configurar a segunda região:

1. Siga os passos em Configure o Apigee hybrid para várias regiões para configurar o anfitrião de sementes de várias regiões na sua plataforma.

2. Para a primeira região criada, obtenha os pods no espaço de nomes apigee:

   kubectl get pods -o wide -n apigee
   

3. Identifique o endereço do anfitrião inicial de várias regiões para o Cassandra nesta região, por exemplo, 10.0.0.11.

4. Prepare o ficheiro overrides.yaml para a segunda região e adicione o endereço IP do anfitrião inicial da seguinte forma:

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

   Substitua o seguinte:

   • SEED_HOST_IP_ADDRESS com o endereço IP do anfitrião inicial, por exemplo, 10.0.0.11.
   • DATACENTER_NAME com o nome do centro de dados, por exemplo, dc-2.
   • RACK_NAME com o nome do suporte, por exemplo, ra-1.
   • CLUSTER_NAME com o nome do seu cluster do Apigee. Por predefinição, o valor é apigeecluster. Se usar um nome de cluster diferente, tem de especificar um valor para cassandra.clusterName. Este valor tem de ser igual em todas as regiões.

Configure a segunda região

Para configurar a nova região:

1. Instale o 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 existente para o novo cluster. A nova raiz da AC é usada pelo Cassandra e outros componentes híbridos para mTLS. Por conseguinte, é essencial ter certificados consistentes no cluster.

   1. Defina o contexto para o espaço de nomes original:

      kubectl config use-context ORIGINAL_CLUSTER_NAME
      

   2. Exporte a configuração do espaço de nomes atual para um ficheiro:

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

   3. Exporte o segredo apigee-ca para um ficheiro:

      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 espaço de nomes para o novo cluster. Certifique-se de que atualiza o espaço de nomes no ficheiro se estiver a usar um espaço de nomes diferente na nova região:

      kubectl apply -f apigee-namespace.yaml
      

   6. Importe o segredo para o novo cluster:

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

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

   Nota: pode usar os mesmos CRDs para consistência usando a mesma pasta onde tem os gráficos transferidos. Também pode manter o ficheiro de substituições exclusivo entre a região 1 e 2 ao atribuir-lhe um nome exclusivo, como overrides2.yaml, etc.

   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
   

   Importante: omita a flag ‑‑atomic para clusters migrados.
4. Depois de instalar todos os componentes, configure o Cassandra em todos os pods nos novos centros de dados. Para obter instruções, consulte o artigo Configure o Apigee Hybrid para várias regiões, selecione a sua plataforma, desloque a página até Configurar a nova região e, de seguida, localize o passo 5.
5. Assim que a replicação de dados estiver concluída e validada, atualize os anfitriões iniciais:
   1. Remova multiRegionSeedHost: 10.0.0.11 de overrides-DATACENTER_NAME.yaml.

      A entrada multiRegionSeedHost já não é necessária após o estabelecimento da replicação de dados, e espera-se que os IPs dos pods mudem ao longo do tempo.

   2. Volte a aplicar a alteração para atualizar o CR do arquivo de dados do Apigee:

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

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

Alojamento de imagens em privado

Em vez de usar o repositório público do Google Cloud, pode optar por alojar as imagens de forma privada. Em vez de substituir cada componente, pode adicionar detalhes do centro nas substituições:

hub: PRIVATE_REPO

Por exemplo, se for fornecido o seguinte hub, o caminho da imagem é resolvido automaticamente:

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

Clique para expandir uma lista de imagens do 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 apresentar uma lista das imagens do Apigee alojadas no repositório do Google Cloud na linha de comandos:

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

Tolerâncias

Para usar a funcionalidade Taints and Tolerations do Kubernetes, tem de definir a propriedade de substituição tolerations para cada componente híbrido do Apigee. Os seguintes componentes suportam 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 acerca destes componentes.

Por exemplo, para aplicar as tolerâncias à implementação do operador do 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

Desinstale o Apigee Hybrid com o Helm

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

Use os passos seguintes para desinstalar completamente o Apigee Hybrid do cluster:

1. Elimine os anfitriões virtuais. Execute este comando para cada virtualhost:

   helm -n apigee delete VIRTUALHOST_RELEASE-NAME
   

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

   helm -n apigee delete ENV_RELEASE-NAME
   

3. elimine a organização do Apigee:

   helm -n apigee delete ORG_RELEASE-NAME
   

4. eliminar telemetria:

   helm -n apigee delete TELEMETRY_RELEASE-NAME
   

5. Eliminar redis:

   helm -n apigee delete REDIS_RELEASE-NAME
   

6. Elimine o gestor de entrada:

   helm -n apigee delete INGRESS_MANAGER_RELEASE-NAME
   

7. Elimine o arquivo de dados:

   helm -n apigee delete DATASTORE_RELEASE-NAME
   

   Dica: se o estado de apigeeds/default permanecer deleting, mas nunca terminar, verifique os pods para ver se uma tarefa de limpeza falhou.
8. Elimine o operador.
   1. Certifique-se de que todos os CRs são eliminados antes de:

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

   2. Elimine o operador do Apigee:

      helm -n apigee-system delete OPERATOR_RELEASE-NAME
      

9. Elimine os CRDs do Apigee Hybrid:

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