Esta página foi traduzida pela API Cloud Translation.

Instale o operador do Apigee para Kubernetes para o Apigee Hybrid

Esta página aplica-se ao Apigee e ao Apigee Hybrid.

Veja a documentação do Apigee Edge.

Esta página descreve os passos necessários para instalar e configurar o Apigee Operator for Kubernetes para o Apigee hybrid. Para saber mais sobre as vantagens de usar o Apigee Operator para Kubernetes, consulte a vista geral do Apigee Operator para Kubernetes.

Se não estiver a usar o Apigee Hybrid, consulte o artigo Instale o operador do Apigee para Kubernetes para instalar o operador do Apigee para Kubernetes para o Apigee.

Antes de começar

Antes de começar, certifique-se de que tem o seguinte:

Funções necessárias

Para as autorizações que tem de definir para configurar os recursos necessários para instalar e usar o Apigee Operator para Kubernetes, peça ao seu administrador que lhe conceda as seguintes funções do IAM na organização:

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

Para mais informações sobre a atribuição de funções, consulte o artigo Faça a gestão do acesso a projetos, pastas e organizações.

Também pode conseguir as autorizações necessárias através de funções personalizadas ou outras funções predefinidas.

Tarefas de configuração necessárias

Antes de instalar o Apigee Operator para Kubernetes, certifique-se de que conclui as seguintes tarefas para configurar os recursos necessários para usar a funcionalidade:

Instale o Apigee hybrid com a versão 1.15.0 ou posterior. Consulte o artigo A visão geral para obter instruções sobre a instalação do Apigee hybrid.
Crie um cluster do Kubernetes num fornecedor de nuvem que suporte o gateway do Istio, como a Google Cloud, o Azure ou a Amazon.
Nota: as instruções nestes procedimentos destinam-se a funcionar com instalações em qualquer fornecedor que suporte o Istio Gateway. Os passos que usam gcloud destinam-se à comunicação com o Google Cloud projeto que contém a sua instância híbrida do Apigee.

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

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

Implemente o Istio Gateway no seu cluster do Kubernetes.

Crie um ficheiro denominado gateway.yaml com o seguinte conteúdo para implementar o gateway Istio com o seguinte conteúdo:

#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 ficheiro ao cluster com o seguinte comando:
```
kubectl apply -f gateway.yaml
```

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

Para os fins deste guia, recomendamos que implemente uma aplicação httpbin de exemplo no espaço de nomes predefinido para testar o gateway que implementou.

Implemente uma aplicação de back-end no cluster do Kubernetes para testar o gateway.
1. Crie um novo ficheiro denominado target.yaml com o seguinte conteúdo no novo ficheiro
```
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
```
  Sugestão: também pode guardar as linhas entre as etiquetas <<EOF e EOF como um ficheiro denominado target.yaml. Em seguida, aplique a configuração ao cluster com o seguinte comando:
```
kubectl apply -f target.yaml
```
2. Implemente o recurso HTTPRoute no seu cluster para mapear o tráfego do Gateway para o seu serviço de back-end.
  Para os fins deste guia, recomendamos que implemente um gateway externo e um HTTPRoute, seguindo os passos em Crie um HTTPRoute.
  
  Para mais informações sobre o recurso HTTPRoute, consulte o artigo Implemente o HTTPRoute (para gateways internos) ou Crie um HTTPRoute (para gateways externos).
  1. Crie um HTTPRoute seguindo as instruções em crie o HTTPRoute com 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 ficheiro ao cluster:
```
kubectl apply -f httproute.yaml
```
3. Valide a configuração do GKE Gateway para confirmar que está a funcionar como esperado.
  Nota: a propagação das alterações aplicadas pode demorar até cinco minutos. Se não vir o resultado esperado para os passos nesta secção, aguarde alguns minutos e tente novamente.
  1. Obtenha os detalhes do gateway através do seguinte comando
```
kubectl get gateway global-ext-lb1
```
    O resultado deve ser semelhante ao seguinte:
```
NAME            CLASS   ADDRESS        PROGRAMMED   AGE
istio-gateway   istio   34.54.193.72   True         11d
```
    Confirme se é atribuído um endereço IP ao gateway e se o valor de PROGRAMMED é True.
  2. Descreva o gateway para confirmar que o trajeto está anexado:
```
kubectl describe gateway istio-gateway
```
    O resultado deve ser semelhante ao seguinte:
```
...
  Listeners:
    Attached Routes: 1
    Conditions:
      Last Transition Time:  2024-10-03T03:10:17Z
...
```
    Confirme se o valor de Attached Routes é 1, o que indica que a rota está anexada.
  3. Envie um pedido ao gateway
```
curl http://GATEWAY_IP_ADDRESS/get \
  -H "Host: example.httpbin.com"
```
    Onde: GATEWAY_IP_ADDRESS é o endereço IP do gateway. Pode obter o endereço IP do gateway através do seguinte comando, em que GATEWAY_NAME é o nome do gateway:
```
kubectl get gateways.gateway.networking.k8s.io GATEWAY_NAME -o=jsonpath="{.status.addresses.value}"
```
    Por exemplo:
```
curl http://34.54.193.72/get -H "Host: example.httpbin.com"
```
    A resposta deve ser semelhante à seguinte:
```
{
    "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"
}
```
Instale o Apigee Operator para Kubernetes

Este procedimento descreve os passos necessários para instalar e configurar o Apigee Operator para Kubernetes.
Instale e configure o operador do Apigee para Kubernetes

As secções seguintes descrevem os passos necessários para instalar e configurar o Apigee Operator para Kubernetes:
Defina variáveis de ambiente

No Google Cloud projeto que contém a 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
```
Onde:
- PROJECT_ID é o ID do projeto com a sua instância do Apigee Hybrid.
- APIGEE_ORG é o nome da organização da sua instância do Apigee Hybrid.
Confirme que as variáveis de ambiente estão definidas corretamente com o seguinte comando:
```
echo $PROJECT_ID $APIGEE_ORG
```
Crie e configure a conta de serviço da APIM

Crie uma conta de serviço para estabelecer ligação ao plano de configuração do Apigee Hybrid.
1. Crie a conta de serviço apigee-apim-gsapara estabelecer ligação aos Google Cloud serviços
2. Conceda a função de administrador do Apigee à conta de serviço que criou através do seguinte comando. Esta função é necessária para criar e gerir recursos do Apigee
```
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member "serviceAccount:apigee-apim-gsa@$PROJECT_ID.iam.gserviceaccount.com" \
  --role "roles/apigee.admin"
```
3. Transfira o ficheiro de chave JSON correspondente para a conta de serviço.
  1. Crie e transfira o ficheiro 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 ficheiro foi transferido corretamente:
```
ls $PROJECT_ID-apigee-apim-gsa.json
        
```
Instale o Apigee Operator para Kubernetes

Instale as definições de recursos personalizados (CRDs) do Kubernetes e o operador do Apigee para Kubernetes:
1. Crie um espaço de nomes para o Apigee Operator 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 do 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 do Apigee Hybrid no qual quer instalar o Apigee Operator para Kubernetes.
4. Confirme que a instalação foi concluída com êxito:
```
helm list -n apim
```
  O resultado deve ser semelhante ao seguinte:
```
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
```
  O resultado deve ser semelhante ao seguinte:
```
Name:                apim-ksa
Namespace:           apim
...
Annotations:         iam.gke.io/gcp-service-account: apigee-apim-gsa@my-project-id.iam.gserviceaccount.com
```
6. Confirme que o Apigee Operator para Kubernetes está em funcionamento nos pods do cluster:
```
kubectl get pods -n apim
```
  O resultado deve ser semelhante ao seguinte:
```
NAME  READY  STATUS  RESTARTS  AGE
apigee-apim-operator-8559d4994b-h55fl   1/1     Running   0   8m34s
```
  Se o STATUS não for Running ou READY não apresentar 1/1, consulte o artigo Resolva problemas do operador do Apigee para Kubernetes para resolver problemas de instalação.
Crie um ambiente do Apigee Hybrid

Para usar o operador do Apigee para Kubernetes no Apigee Hybrid, tem de criar um ambiente com uma flag especial para a extensão de serviços.
1. Obtenha um token para fazer a autenticação na API Apigee.
  Na linha de comandos, obtenha as suas gcloud credenciais de autenticação, como mostra o exemplo seguinte:
```
TOKEN=$(gcloud auth print-access-token)
```
  Para verificar se o token foi preenchido, use echo, como mostra o exemplo seguinte:
```
echo $TOKEN
```
  Esta ação deve apresentar o seu token como uma string codificada.
  
  Para mais informações, consulte a vista geral da ferramenta de linhas de comando gcloud.
2. Crie o ambiente com um dos seguintes comandos:
  - Para organizações com subscrição 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 quer criar.
  - Para organizações com subscrição de 2024 e pagamento conforme o uso:
```
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"
      }
    ]
  }
}'
```
    Onde:
    - ENV_NAME é o nome do ambiente que quer criar.
    - ENV_TYPE é o tipo de ambiente que quer criar. Por exemplo, INTERMEDIATE ou COMPREHENSIVE.
  Verifique se o ambiente foi criado com êxito:
```
curl -i -H "Authorization: Bearer $TOKEN" \
  "https://apigee.googleapis.com/v1/organizations/$APIGEE_ORG/environments"
```
  Consulte o artigo Crie um ambiente nas instruções de instalação do Apigee Hybrid para mais informações.
3. Crie um grupo de ambientes 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"'"]
   }'
```
  Onde:
  - ENV_GROUP (Obrigatório) O nome do ambiente pode conter letras minúsculas, traços e números, e tem de começar por uma letra minúscula. Este nome vai ser usado como identificador e não pode ser alterado após a criação.
  - DOMAIN (Obrigatório) Este é o nome do anfitrião que todos os proxies implementados em ambientes dentro deste grupo vão usar. Este deve ser um domínio que gere. 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 não tiver um domínio gerido, pode introduzir um marcador de posição por agora. Pode alterar o endereço do domínio mais tarde.
  Consulte o artigo Crie um grupo de ambientes nas instruções de instalação do Apigee hybrid para mais informações.
4. Associe o ambiente ao grupo de ambientes que 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"'",
   }'
```
Instale o ambiente do Apigee Hybrid com o Helm

O procedimento para instalar o novo ambiente no cluster do Apigee Hybrid é semelhante ao modo como instalou outros ambientes no seu cluster. Isto é necessário para adicionar novos detalhes do ambiente e do grupo de ambientes ao nosso cluster do Kubernetes no qual o Apigee Hybrid foi instalado.
1. Gere o certificado TLS para o domínio do grupo de ambientes 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
```
  Onde:
  - APIGEE_HELM_CHARTS_HOME (Obrigatório) Diretório onde transferiu os gráficos Helm do Apigee durante a instalação do Apigee Hybrid.
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 ficheiro 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"
```
  Onde *_SERVICE_ACCOUNT_FILEPATH (Obrigatório) é o ficheiro de chave JSON da conta de serviço que usou durante a instalação do Apigee Hybrid. Consulte o artigo Crie as substituições nas instruções de instalação do Apigee Hybrid para mais informações.
4. Adicione a seguinte entrada no ficheiro 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 da gateway de entrada da Apigee para a sua implementação. Consulte aqui para mais informações.
5. Instale o ambiente e o grupo de ambientes
  1. Instale o ambiente.
    
    Tem de instalar um ambiente de cada vez. Especifique o ambiente com --set env=ENV_NAME. Se tiver definido a variável de ambiente $ENV_NAME na sua shell, pode usá-la nos seguintes comandos:
    
    Execução de ensaio:
```
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
```
    Verifique se está em funcionamento consultando o estado do ambiente respetivo:
```
kubectl -n APIGEE_NAMESPACE get apigeeenv
```
```
NAME                    STATE       AGE   GATEWAYTYPE
apigee-org1-dev-1       running     2d
```
  2. Instale os grupos de ambientes (virtualhosts).
    1. Tem de instalar um grupo de ambientes (virtualhost) de cada vez. Especifique o grupo do ambiente com --set envgroup=ENV_GROUP. Se tiver definido a variável de ambiente $ENV_GROUP no seu shell, pode usá-la nos comandos seguintes. Repita os seguintes comandos para cada grupo de ambiente mencionado no seu ficheiro overrides.yaml:
      Execução de ensaio:
      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
      Nota: ENV_GROUP tem de ser exclusivo no espaço de nomes apigee. Por exemplo, se tiver um prod env e um envgroup, deve definir este nome como prod-envgroup. O nome do grupo de ambientes posterior deve continuar a ser prod.
  A sua organização do Apigee Hybrid está agora pronta com o novo ambiente para testar a extensão de serviço.
  
  Continue com os procedimentos em Crie um APIMExtensionPolicy para criar uma política de extensões.

Instale o operador do Apigee para Kubernetes para o Apigee Hybrid 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 necessárias

Tarefas de configuração necessárias

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

Instale o Apigee Operator para Kubernetes

Instale e configure o operador do Apigee para Kubernetes

Defina variáveis de ambiente

Crie e configure a conta de serviço da APIM

Instale o Apigee Operator para Kubernetes

Crie um ambiente do Apigee Hybrid

Instale o ambiente do Apigee Hybrid com o Helm

Instale o operador do Apigee para Kubernetes para o Apigee Hybrid