Esta página foi traduzida pela API Cloud Translation.

Instalar o operador da Apigee para Kubernetes na Apigee híbrida

Esta página se aplica à Apigee e à Apigee híbrida.

Confira a documentação da Apigee Edge.

Nesta página, descrevemos as etapas necessárias para instalar e configurar o operador da Apigee para Kubernetes na Apigee híbrida. Para saber mais sobre os benefícios de usar o operador do Apigee para Kubernetes, consulte Visão geral do operador do Apigee para Kubernetes.

Se você não estiver usando a Apigee híbrida, consulte Instalar o operador da Apigee para Kubernetes e instale o operador da Apigee para Kubernetes na Apigee.

Antes de começar

Antes de começar, verifique se você tem:

Funções exigidas

Para as permissões necessárias para configurar os recursos necessários para instalar e usar o operador do Apigee para Kubernetes, peça ao administrador que conceda a você os seguintes papéis do IAM na organização:

Criar e gerenciar contas de serviço: administrador da conta de serviço (roles/iam.serviceAccountAdmin)
Criar e gerenciar recursos da Apigee: administrador da Apigee (roles/apigee.admin)

Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Também é possível conseguir as permissões necessárias com papéis personalizados ou outros papéis predefinidos.

Tarefas de configuração obrigatórias

Antes de instalar o operador da Apigee para Kubernetes, conclua as seguintes tarefas para configurar os recursos necessários para usar o recurso:

Instale a Apigee híbrida usando a versão 1.15.0 ou mais recente. Consulte Visão geral para instruções de instalação da Apigee híbrida.
Crie um cluster do Kubernetes em um provedor de nuvem que ofereça suporte ao gateway do Istio, como Google Cloud, Azure ou Amazon.
Observação:as instruções nestes procedimentos foram criadas para funcionar com instalações em qualquer provedor compatível com o Istio Gateway. As etapas que usam gcloud são para comunicação com o Google Cloud projeto que contém sua instância da Apigee híbrida.

Instale o gateway do Istio no cluster do K8s:

Para clusters no GKE:

kubectl apply -f https://github.com/kubernetes-sigs/gateway-api/releases/download/v1.1.0/standard-install.yaml
curl -L https://istio.io/downloadIstio | sh -
cd 1.6.11-asm.1
export PATH=$PWD/bin:$PATH
istioctl install --set profile=minimal --set values.global.platform=gke -y

Para clusters em outros provedores:

kubectl apply -f https://github.com/kubernetes-sigs/gateway-api/releases/download/v1.1.0/standard-install.yaml
curl -L https://istio.io/downloadIstio | sh -
cd 1.6.11-asm.1
export PATH=$PWD/bin:$PATH
istioctl install --set profile=minimal -y

Implante o gateway do Istio no cluster do Kubernetes.

Crie um arquivo chamado gateway.yaml com o seguinte conteúdo para implantar o gateway do Istio:

#gateway.yaml
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: istio-gateway
  namespace: default
  annotations:
    service.beta.kubernetes.io/port_80_health-probe_protocol: tcp
spec:
  gatewayClassName: istio
  listeners:
  - name: default
    hostname: "*.httpbin.com"
    port: 80
    protocol: HTTP
    allowedRoutes:
      namespaces:
        from: All

Aplique o arquivo ao cluster com o seguinte comando:
```
kubectl apply -f gateway.yaml
```

Verificar a configuração do gateway do Istio (opcional)

Para fins deste guia, recomendamos que você implante um aplicativo httpbin de amostra no namespace padrão para testar o gateway implantado.

Implante um aplicativo de back-end no cluster do Kubernetes para testar o gateway.
1. Crie um novo arquivo chamado target.yaml com o seguinte conteúdo:
```
kubectl apply -f - <<EOF
apiVersion: v1
kind: ServiceAccount
metadata:
  name: httpbin
---
apiVersion: v1
kind: Service
metadata:
  name: httpbin
  labels:
    app: httpbin
    service: httpbin
spec:
  ports:
  - name: http
    port: 8000
    targetPort: 8080
  selector:
    app: httpbin
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: httpbin
spec:
  replicas: 1
  selector:
    matchLabels:
      app: httpbin
      version: v1
  template:
    metadata:
      labels:
        app: httpbin
        version: v1
    spec:
      serviceAccountName: httpbin
      containers:
      - image: docker.io/mccutchen/go-httpbin:v2.15.0
        imagePullPolicy: IfNotPresent
        name: httpbin
        ports:
        - containerPort: 8080
EOF
```
  Dica:também é possível salvar as linhas entre as tags <<EOF e EOF como um arquivo chamado target.yaml. Em seguida, aplique a configuração ao cluster com o seguinte comando:
```
kubectl apply -f target.yaml
```
2. Implante o recurso HTTPRoute no cluster para mapear o tráfego do gateway para o serviço de back-end.
  Para os fins deste guia, recomendamos que você implante um gateway externo e um HTTPRoute seguindo as etapas em Criar um HTTPRoute.
  
  Para mais informações sobre o recurso HTTPRoute, consulte Implantar o HTTPRoute (para gateways internos) ou Criar um HTTPRoute (para gateways externos).
  1. Crie um HTTPRoute seguindo as instruções em criar o HTTPRoute usando a seguinte configuração YAML:
```
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: http-bin-route
  namespace: default
spec:
  parentRefs:
  - name: istio-gateway
    namespace: default
  hostnames: ["example.httpbin.com"]
  rules:
  - matches:
    - path:
        type: PathPrefix
        value: /get
    backendRefs:
    - name: httpbin
      port: 8000
```
  2. Aplique o arquivo ao cluster:
```
kubectl apply -f httproute.yaml
```
3. Verifique a configuração do gateway do GKE para confirmar se ele está funcionando como esperado.
  Observação:pode levar até cinco minutos para que as mudanças aplicadas sejam propagadas. Se você não vir a saída esperada para as etapas desta seção, aguarde alguns minutos e tente novamente.
  1. Confira os detalhes do gateway usando o seguinte comando:
```
kubectl get gateway global-ext-lb1
```
    A saída será semelhante a:
```
NAME            CLASS   ADDRESS        PROGRAMMED   AGE
istio-gateway   istio   34.54.193.72   True         11d
```
    Confirme se um endereço IP foi atribuído ao gateway e se o valor de PROGRAMMED é True.
  2. Descreva o gateway para confirmar se a rota está anexada:
```
kubectl describe gateway istio-gateway
```
    A saída será parecida com esta:
```
...
  Listeners:
    Attached Routes: 1
    Conditions:
      Last Transition Time:  2024-10-03T03:10:17Z
...
```
    Confirme se o valor de "Rotas anexadas" é 1, indicando que a rota está anexada.
  3. Enviar uma solicitação para o gateway
```
curl http://GATEWAY_IP_ADDRESS/get \
  -H "Host: example.httpbin.com"
```
    Em que: GATEWAY_IP_ADDRESS é o endereço IP do gateway. É possível recuperar o endereço IP do gateway usando o seguinte comando, em que GATEWAY_NAME é o nome do gateway:
```
kubectl get gateways.gateway.networking.k8s.io GATEWAY_NAME -o=jsonpath="{.status.addresses.value}"
```
    Exemplo:
```
curl http://34.54.193.72/get -H "Host: example.httpbin.com"
```
    A resposta será semelhante a esta:
```
{
    "args": {},
    "headers": {
      "Accept": "*/*",
      "Host": "http://example.httpbin.com",
      "User-Agent": "curl/8.7.1",
      "X-Cloud-Trace-Context": "2bb8a80e29e80662ff9cb89971c447d9/13083106619927322701"
    },
    "origin": "67.164.1.10,34.54.193.72",
    "url": "http://example.httpbin.com/get"
}
```
Instalar o operador da Apigee para Kubernetes

Este procedimento descreve as etapas necessárias para instalar e configurar o operador da Apigee para Kubernetes.
Instalar e configurar o operador da Apigee para Kubernetes

As seções a seguir descrevem as etapas necessárias para instalar e configurar o operador da Apigee para Kubernetes:
Defina as variáveis de ambiente

No projeto Google Cloud que contém sua instância do Apigee, use o seguinte comando para definir variáveis de ambiente:
```
export PROJECT_ID=PROJECT_ID
export APIGEE_ORG=APIGEE_ORG
```
Em que:
- PROJECT_ID é o ID do projeto com sua instância do Apigee Hybrid.
- APIGEE_ORG é o nome da organização da sua instância do Apigee híbrido.
Confirme se as variáveis de ambiente estão definidas corretamente com o seguinte comando:
```
echo $PROJECT_ID $APIGEE_ORG
```
Criar e configurar a conta de serviço do APIM

Crie uma conta de serviço para se conectar ao plano de configuração do Apigee Hybrid.
1. Crie a conta de serviço apigee-apim-gsa para se conectar aos serviços Google Cloud
2. Conceda o papel de administrador do Apigee à conta de serviço que você criou usando o seguinte comando. Esse papel é necessário para criar e gerenciar recursos da Apigee.
```
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member "serviceAccount:apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com" \
  --role "roles/apigee.admin"
```
3. Faça o download do arquivo de chave JSON correspondente para a conta de serviço.
  1. Crie e faça o download do arquivo de chave $PROJECT_ID-apigee-apim-gsa.json com o seguinte comando:
```
gcloud iam service-accounts keys create $PROJECT_ID-apigee-apim-gsa.json \
  --iam-account=apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com
  --project=$PROJECT_ID
        
```
  2. Verifique se o arquivo foi baixado corretamente:
```
ls $PROJECT_ID-apigee-apim-gsa.json
        
```
Instalar o operador da Apigee para Kubernetes

Instale as definições de recursos personalizados (CRDs) do Kubernetes e o operador do Apigee para Kubernetes:
1. Crie um namespace para o operador do Apigee para Kubernetes
```
kubectl create namespace apim
```
2. Instale o operador do Apigee para definições de recursos personalizados (CRDs) do Kubernetes:
```
helm install apigee-apim-crds -n apim \
  oci://us-docker.pkg.dev/apigee-release/apigee-k8s-tooling-helm-charts/apigee-apim-operator-crds \
  --version 1.1.0 \
  --atomic
```
3. Instale o operador da Apigee para Kubernetes:
```
helm install apigee-apim-operator -n apim \
  oci://us-docker.pkg.dev/apigee-release/apigee-k8s-tooling-helm-charts/apigee-apim-operator-helm \
  --version 1.1.0 \
  --set serviceAccount=apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com \
  --set apigeeOrg=$APIGEE_ORG \
  --set apigeeEnv=ENV_NAME \
  --set-file serviceAccountKeyFileContent=$PROJECT_ID-apigee-apim-gsa-key.json \
  --atomic
```
  Em que ENV_NAME é o nome do ambiente da Apigee híbrida em que você quer instalar o operador da Apigee para Kubernetes.
4. Confirme se a instalação foi concluída corretamente:
```
helm list -n apim
```
  A saída será parecida com esta:
```
NAME  NAMESPACE  REVISION  UPDATED  STATUS  CHART  APP VERSION
apigee-apim-crds  apim  1  2025-09-01 00:17:03.399810627 +0000 UTC  deployed  apigee-apim-operator-crds-1.1.0  1.1.0
apigee-apim-operator  apim  1  2025-09-01 00:15:00.362829981 +0000 UTC  deployed  apigee-apim-operator-helm-1.1.0  1.1.0
```
5. Confirme se a conta de serviço do Kubernetes (KSA) foi criada com a anotação necessária:
```
kubectl describe serviceaccounts apim-ksa -n apim
```
  A saída será parecida com esta:
```
Name:                apim-ksa
Namespace:           apim
...
Annotations:         iam.gke.io/gcp-service-account: apigee-apim-gsa@my-project-id.iam.gserviceaccount.com
```
6. Confirme se o operador do Apigee para Kubernetes está em execução nos pods do cluster:
```
kubectl get pods -n apim
```
  A saída será parecida com esta:
```
NAME  READY  STATUS  RESTARTS  AGE
apigee-apim-operator-8559d4994b-h55fl   1/1     Running   0   8m34s
```
  Se o STATUS não for "Running" ou se READY não mostrar "1/1", consulte "Resolver problemas do operador do Apigee para Kubernetes" para solucionar problemas na instalação.
Criar um ambiente híbrido da Apigee

Para usar o operador da Apigee para Kubernetes na Apigee híbrida, crie um ambiente com uma flag especial para extensão de serviço.
1. Receba um token para autenticar na API Apigee.
  Na linha de comando, receba as credenciais de autenticação de gcloud. Veja o exemplo a seguir:
```
TOKEN=$(gcloud auth print-access-token)
```
  Para verificar se o token foi preenchido, use echo, como mostra o exemplo a seguir:
```
echo $TOKEN
```
  Isso exibirá seu token como uma string codificada.
  
  Para mais informações, consulte a visão geral da ferramenta de linha de comando gcloud.
2. Crie o ambiente usando um dos seguintes comandos:
  - Para organizações com assinatura de 2021:
```
curl -X POST "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/environments" -H \
  "Authorization: Bearer $TOKEN" -H "content-type:application/json" \
    -d '{
      "name": "ENV_NAME",
      "displayName": "ENV_DISPLAY_NAME",
      "state": "ACTIVE",
      "deploymentType": "PROXY",
      "apiProxyType": "PROGRAMMABLE",
      "properties": {
        "property": [
          {
            "name": "apigee-service-extension-enabled",
            "value": "true"
          }
        ]
      }
    }'
```
    Em que ENV_NAME é o nome do ambiente que você quer criar.
  - Para organizações com assinatura de 2024 e pagamento por utilização:
```
curl -i -X POST -H "Authorization: Bearer $TOKEN"  "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/environments" -H "Content-Type:application/json" -d '{
  "name": "ENV_NAME",
  "displayName": "ENV_NAME",
  "state": "ACTIVE",
  "deploymentType": "PROXY",
  "apiProxyType": "PROGRAMMABLE",
  "type" : "ENV_TYPE",
  "properties": {
    "property": [
      {
        "name": "apigee-service-extension-enabled",
        "value": "true"
      }
    ]
  }
}'
```
    Em que:
    - ENV_NAME é o nome do ambiente que você quer criar.
    - ENV_TYPE é o tipo de ambiente que você quer criar. Por exemplo, INTERMEDIATE ou COMPREHENSIVE.
  Verifique se o ambiente foi criado:
```
curl -i -H "Authorization: Bearer $TOKEN" \
  "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/environments"
```
  Consulte Criar um ambiente nas instruções de instalação da Apigee híbrida para mais informações.
3. Crie um grupo de ambiente com o seguinte comando:
```
curl -i -X POST -H "Authorization: Bearer $TOKEN"  "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/envgroups" -H "Content-Type:application/json" -d '{
     "name": "'"$ENV_GROUP"'",
     "hostnames":["'"$DOMAIN"'"]
   }'
```
  Em que:
  - ENV_GROUP (Obrigatório) O nome do ambiente pode conter letras minúsculas, traços e números e precisa começar com uma letra minúscula. Esse nome será usado como o identificador e não poderá ser mudado depois da criação.
  - DOMAIN (Obrigatório) Este é o nome do host que todos os proxies implantados nos ambientes deste grupo vão usar. Este deve ser um domínio que você gerencia. O endereço pode ser o próprio domínio, como example.com, ou pode incluir um subdomínio, como my-proxies.example.com. Se você não tiver um domínio gerenciado, insira um marcador por enquanto. É possível alterar o endereço do domínio depois.
  Consulte Criar um grupo de ambientes nas instruções de instalação da Apigee híbrida para mais informações.
4. Anexe o ambiente ao grupo de ambiente que você acabou de criar com o seguinte comando:
```
curl -i -X POST -H "Authorization: Bearer $TOKEN"  "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/envgroups/$ENV_GROUP/attachments" -H "Content-Type:application/json" -d '{
     "environment": "'"$ENV_NAME"'",
   }'
```
Instalar o ambiente híbrido da Apigee usando o Helm

O procedimento para instalar o novo ambiente no cluster da Apigee híbrida é semelhante à instalação de outros ambientes no cluster. Isso é necessário para adicionar novos detalhes de ambiente e grupo de ambientes ao cluster do Kubernetes em que a Apigee híbrida foi instalada.
1. Gere o certificado TLS para o domínio do grupo de ambiente com o seguinte comando:
```
openssl req -nodes -new -x509 -keyout $APIGEE_HELM_CHARTS_HOME/apigee-virtualhost/certs/keystore_$ENV_GROUP.key -out $APIGEE_HELM_CHARTS_HOME/apigee-virtualhost/certs/keystore_$ENV_GROUP.pem -subj "/CN=$DOMAIN" -addext "subjectAltName = DNS:$DOMAIN" -days 3650
```
  Em que:
  - APIGEE_HELM_CHARTS_HOME (obrigatório): diretório em que você fez o download dos gráficos do Apigee Helm durante a instalação da Apigee híbrida.
2. Codifique em Base64 o certificado público TLS com o seguinte comando:
```
cat $APIGEE_HELM_CHARTS_HOME/apigee-virtualhost/certs/keystore_$ENV_GROUP.pem | base64 -w0 > $APIGEE_HELM_CHARTS_HOME/apigee-virtualhost/certs/keystore_$ENV_GROUP.pem.base64
```
3. Atualize o arquivo overrides.yaml com a seguinte entrada em envs
```
- name: ENV_NAME
  serviceAccountPaths:
    # Provide the path relative to the apigee-env chart directory.
    synchronizer: SYNCHRONIZER_SERVICE_ACCOUNT_FILEPATH
    # For example: "PROJECT_ID-apigee-synchronizer.json"
    runtime: RUNTIME_SERVICE_ACCOUNT_FILEPATH
    # For example: "PROJECT_ID-apigee-runtime.json"
    udca: UDCA_SERVICE_ACCOUNT_FILEPATH
    # For example: "PROJECT_ID-apigee-udca.json"
```
  Em que *_SERVICE_ACCOUNT_FILEPATH (obrigatório) é o arquivo de chave JSON da conta de serviço usada durante a instalação da Apigee híbrida. Consulte Criar substituições nas instruções de instalação da Apigee híbrida para mais informações.
4. Adicione a seguinte entrada ao arquivo "overrides.yaml" em "virtualhosts":
```
- name: 
  selector:
    app: apigee-ingressgateway
    ingress_name: INGRESS_NAME
  sslCertPath: certs/keystore_$ENV_GROUP.pem
  sslKeyPath: certs/keystore_$ENV_GROUP.key
```
  Em que INGRESS_NAME (obrigatório) é o nome do gateway de entrada da Apigee para sua implantação. Consulte aqui para mais informações.
5. Instalar o ambiente e o grupo de ambientes
  1. Instale o ambiente.
    
    É preciso instalar um ambiente de cada vez. Especifique o ambiente com --set env=ENV_NAME: Se você tiver definido a variável de ambiente $ENV_NAME no shell, poderá usá-la nos seguintes comandos:
    
    Simulação:
```
helm upgrade ENV_RELEASE_NAME apigee-env/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  --set env=$ENV_NAME \
  -f overrides.yaml \
  --dry-run=server
```
    Instale o gráfico:
```
helm upgrade ENV_RELEASE_NAME apigee-env/ \
  --install \
  --namespace APIGEE_NAMESPACE \
  --atomic \
  --set env=$ENV_NAME \
  -f overrides.yaml
```
    Para saber se ele está funcionando, confira o estado do respectivo ambiente:
```
kubectl -n APIGEE_NAMESPACE get apigeeenv
```
```
NAME                    STATE       AGE   GATEWAYTYPE
apigee-org1-dev-1       running     2d
```
  2. Instale os grupos de ambientes (virtualhosts).
    1. É necessário instalar um grupo de ambiente (virtualhost) por vez. Especifique o grupo de ambientes com --set envgroup=ENV_GROUP: Se você tiver definido a variável de ambiente $ENV_GROUP no shell, poderá usá-la nos seguintes comandos. Repita os seguintes comandos para cada grupo de ambiente mencionado no arquivo overrides.yaml:
      Simulação:
      helm upgrade ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \ --install \ --namespace APIGEE_NAMESPACE \ --atomic \ --set envgroup=$ENV_GROUP \ -f overrides.yaml \ --dry-run=server
      Instale o gráfico:
      helm upgrade $ENV_GROUP_RELEASE_NAME apigee-virtualhost/ \ --install \ --namespace APIGEE_NAMESPACE \ --atomic \ --set envgroup=$ENV_GROUP \ -f overrides.yaml
      Observação: ENV_GROUP precisa ser exclusivo no namespace apigee. Por exemplo, se você tiver um env e envgroup prod, defina esse nome como prod-envgroup. O nome do grupo de ambientes posterior ainda precisa ser prod.
  Sua organização do Apigee Hybrid agora está pronta com o novo ambiente para testar a extensão de serviço.
  
  Continue com os procedimentos em Criar um APIMExtensionPolicy para criar uma política de extensão.

Instalar o operador da Apigee para Kubernetes na Apigee híbrida Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Antes de começar

Funções exigidas

Tarefas de configuração obrigatórias

Verificar a configuração do gateway do Istio (opcional)

Instalar o operador da Apigee para Kubernetes

Instalar e configurar o operador da Apigee para Kubernetes

Defina as variáveis de ambiente

Criar e configurar a conta de serviço do APIM

Instalar o operador da Apigee para Kubernetes

Criar um ambiente híbrido da Apigee

Instalar o ambiente híbrido da Apigee usando o Helm

Instalar o operador da Apigee para Kubernetes na Apigee híbrida