Esta página foi traduzida pela API Cloud Translation.

Tarefas de integração do Kubernetes

Você está visualizando a documentação do Apigee Edge.
Acesse a documentação da Apigee X. info

Como adicionar um plug-in personalizado

É possível adicionar novos recursos e capacidades ao microgateway escrevendo plug-ins personalizados. Os plug-ins personalizados permitem interagir de forma programática com as solicitações e respostas que fluem pela microgateway.

Esta seção explica como empacotar e implantar plug-ins em uma instância do Edge Microgateway executada no cluster do Kubernetes.

O restante desta seção pressupõe que você já sabe como criar e configurar plug-ins para uma configuração padrão do Edge Microgateway. Caso contrário, consulte Desenvolver plug-ins personalizados.

Empacotar seus plug-ins

Para empacotar plug-ins personalizados, siga estas etapas:

Crie e teste o plug-in de acordo com as instruções em Criar um plug-in simples.
Coloque o código do plug-in na estrutura de diretório adequada. Os diretórios de plug-ins precisam seguir uma estrutura definida. O exemplo a seguir mostra a estrutura que você precisa seguir, em que response-uppercase e request-headers são os nomes das pastas que contêm o código do plug-in personalizado. Esses nomes são apenas exemplos, os nomes das pastas podem ser diferentes:
```
plugin
  |
  |-- plugins
    |
    |- response-uppercase
    |     |- index.js
    |     |- package.json
    |- request-headers
    |     | - index.js
          | - package.json
```
cd para a pasta plugin.
Na pasta plugin, compacte toda a pasta plugins:
```
zip -r plugins.zip plugins/
```

Criar uma imagem do Docker

No mesmo diretório em que o arquivo ZIP está localizado, crie um novo arquivo chamado Dockerfile.

Adicione o seguinte código a Dockerfile e salve o arquivo:

FROM gcr.io/apigee-microgateway/edgemicro:latest
RUN apt-get install unzip
COPY plugins.zip /opt/apigee/
RUN chown apigee:apigee /opt/apigee/plugins.zip
RUN su - apigee -c "unzip /opt/apigee/plugins.zip -d /opt/apigee"
EXPOSE 8000
EXPOSE 8443
ENTRYPOINT ["entrypoint"]

Crie uma nova imagem do Docker do Edge Microgateway com seus plug-ins e envie a imagem para o registro do Docker. Você pode usar o registro que quiser, como docker.io ou gcr.io:
```
docker build -t edgemicroplugins .
docker tag edgemicroplugins container-registry/your-project/edgemicroplugins
docker push container-registry/your-project/edgemicroplugins
```
Exemplo:
```
docker build -t edgemicroplugins .
docker tag edgemicroplugins gcr.io/my-project/edgemicroplugins
docker push   gcr.io/my-project/edgemicroplugins
```
Observação: se você estiver usando o Google Container Registry (GCR), verifique se a imagem enviada tem as permissões adequadas. Por exemplo, para veicular a imagem publicamente, torne o bucket de armazenamento do Container Registry acessível ao público. Basta executar o comando a seguir. Por exemplo: gsutil iam ch allUsers:objectViewer gs://[BUCKET_NAME]

Atualizar a configuração do Edge Microgateway

Adicione os plug-ins ao arquivo de configuração do Edge Microgateway. O arquivo de configuração pode ser encontrado aqui:
```
$HOME/.edgemicro/org-env-config.yaml
```
Exemplo:
```
$HOME/.edgemicro/myorg-test-config.yaml
```

No exemplo de configuração abaixo, o plug-in personalizado response-uppercase foi adicionado. O plug-in oauth já estava lá por padrão.

  edgemicro:
    ...
    plugins:
      sequence:
        - oauth
        - response-uppercase

Atualizar o cluster do Kubernetes

A etapa final é aplicar a mudança de configuração ao cluster do Kubernetes. O Kubernetes extrai a nova imagem com o código do plug-in que você enviou ao registro de contêineres e a usa para todos os pods recém- criados.

Se você implantou o Edge Microgateway como um serviço

Use o comando edgemicroctl para injetar a configuração atualizada do Edge Microgateway:

Atualize a implantação do Edge Microgateway com a nova imagem. Exemplo:
```
kubectl apply -f <(edgemicroctl -org=your_organization -env=your_environment -key=configuration_key -sec=configuration_secret -conf=config_file_path -img=container-registry/your_project_name/image_name:latest)
```
em que:
- your_organization: a organização da Apigee especificada no comando edgemicro configure.
- your_environment: o ambiente especificado no comando edgemicro configure.
- configuration_key: a chave retornada pelo comando edgemicro configure.
- configuration_secret: o secret retornado do comando edgemicro configure.
- config_file_path: o caminho para o arquivo de configuração do Edge Micro retornado pelo comando edgemicro configure.
- container-registry: o registro do Docker em que você enviou a imagem. Por exemplo, gcr.io ou docker.io.
- your_project_name: o nome do projeto do repositório do Docker para onde você enviou a imagem do Docker.
- image_name: o nome da imagem do Docker que você enviou.
Exemplo:
```
kubectl apply -f <(edgemicroctl -org=jdoe -env=test -key=f2d2eaa52b758493d00cec656e574ac947bee1d701c5c5f3295e5eaa39a3b -sec=0c38cda3fac6c59152f15657052ba1728f8003c1a763cf08da2a -conf=/Users/jdoe/.edgemicro/apigeesearch-test-config.yaml -img=gcr.io/jdoe-project/edgemicroplugins:latest)
```
Teste o plug-in. Chame a API para conferir se você recebe o comportamento esperado. Por exemplo, para o plug-in "response uppercase", o texto da resposta é convertido em letras maiúsculas, conforme mostrado abaixo:
```
curl $GATEWAY_IP -H 'x-api-key:3eqeedJRFLlCshwWBiXq4xKFoH1Se3xR'
```
Saída:
```
HELLO WORLD
```

Como injetar manualmente a nova configuração

A injeção manual é uma abordagem simples, em que você injeta a nova configuração na linha de comando.

Execute o seguinte comando:
```
kubectl apply -f <(edgemicroctl -org=your_org -env=your_env -key=your_key -sec=your_secret -conf=config_file_path -img=container-registry/your_project_name/image_name:latest -svc=service_deployment_file)
```
em que:
- your_org: a organização da Apigee especificada no comando edgemicro configure.
- your_env: o ambiente especificado no comando edgemicro configure.
- your_key: a chave retornada pelo comando edgemicro configure.
- your_secret: o secret retornado do comando edgemicro configure.
- config_file_path: o caminho para o arquivo de configuração do Edge Micro retornado pelo comando edgemicro configure.
- container-registry: o registro do Docker em que você enviou a imagem. Por exemplo, gcr.io ou docker.io.
- your_project_name: o nome do projeto do repositório do Docker para onde você enviou a imagem do Docker.
- image_name: o nome da imagem do Docker que você enviou.
- service_deployment_file: o caminho para o arquivo de implantação do serviço para o qual os plug-ins serão aplicados. Por exemplo, samples/helloworld/helloworld.yaml.
Exemplo:
```
kubectl apply -f <(edgemicroctl -org=myorg -env=test-key=0e3ecea28a64099410594406b30e54439af5265f8 -sec=e3919250bee37c69cb2e5b41170b488e1c1d -conf=/Users/jdoe/.edgemicro/myorg-test-config.yaml -img=gcr.io/myproject/edgemicroplugins:latest -svc=samples/helloworld/helloworld.yaml)
```
Teste o plug-in. Chame a API do serviço para ver se você recebe o comportamento esperado. Por exemplo, no plug-in "response uppercase", o texto da resposta é convertido em letras maiúsculas, conforme mostrado abaixo:
```
curl $GATEWAY_IP -H 'x-api-key:3eqeedJRFLlCshwWBiXq4xKFoH1Se3xR'
```
Saída:
```
HELLO WORLD
```

Como fazer mudanças na configuração do Edge Microgateway

Em alguns casos, talvez seja necessário modificar a configuração do Edge Microgateway. Por exemplo, você pode querer adicionar um novo plug-in ao Edge Microgateway ou mudar um parâmetro de configuração. Esta seção explica como fazer e aplicar mudanças de configuração no Edge Microgateway em execução no Kubernetes.

Crie um arquivo de configuração secret.yaml, conforme mostrado abaixo:

Observação: as informações necessárias para fazer atualizações de configuração são armazenadas em um objeto secreto do Kubernetes chamado mgwsecret.
```
apiVersion: v1
kind: Secret
metadata:
  name: mgwsecret
type: Opaque
data:
  mgorg: EDGEMICRO_ORG
  mgenv: EDGEMICRO_ENV
  mgkey: EDGEMICRO_KEY
  mgsecret: EDGEMICRO_SECRET
  mgconfig: EDGEMICRO_CONFIG
```

Especifique o valor codificado em base64 de EDGEMICRO_ORG, EDGEMICRO_ENV, EDGEMICRO_KEY e EDGEMICRO_SECRET:

echo -n "your-org" | base64 | tr -d '\n'
echo -n "your-org-env" | base64 | tr -d '\n'
echo -n "your-mg-key" | base64 | tr -d '\n'
echo -n "your-mg-secret" | base64 | tr -d '\n'

Faça as mudanças no arquivo de configuração do Edge Microgateway para sua organização e ambiente:
```
$HOME/.edgemicro/your_org-your_env-config.yaml
```

Codifique em Base64 o conteúdo do arquivo de configuração duas vezes:

cat $HOME/.edgemicro/org-env-config.yaml | base64 | tr -d '\n' | base64  | tr -d '\n'

Aplique as mudanças ao Kubernetes no namespace em que o serviço está sendo executado.
```
kubectl apply -f secret.yaml -n 
```

Essas novas mudanças não são detectadas automaticamente pelos pods de microgateway atuais. No entanto, os novos pods vão receber as mudanças. Você pode excluir o pod atual para que a implantação crie um novo pod que detecte a mudança.

Exemplo de serviço

O exemplo a seguir ilustra como atualizar uma implantação de serviço com um novo

Conseguir os pods.

kubectl get pods

Exemplo de saída:

NAME                                 READY     STATUS    RESTARTS   AGE
edge-microgateway-57ccc7776b-g7nrg   1/1       Running   0          19h
helloworld-6987878fc4-cltc2          1/1       Running   0          1d

Exclua o pod edge-microgateway.

kubectl delete pod edge-microgateway-57ccc7776b-g7nrg

Exemplo de saída:

pod "edge-microgateway-57ccc7776b-g7nrg" deleted

Acesse os pods novamente. Um novo pod é iniciado e recebe as mudanças de configuração.

kubectl get pods

Exemplo de saída:

NAME                                 READY     STATUS    RESTARTS   AGE
edge-microgateway-57ccc7776b-7f6tc   1/1       Running   0          5s
helloworld-6987878fc4-cltc2          1/1       Running   0          1d

Como escalonar a implantação

Esta seção explica como usar os princípios de escalonamento do Kubernetes para dimensionar as implantações.

Como dimensionar uma implantação de serviço

Verifique as implantações:

kubectl get deployments

Exemplo de saída:

NAME                DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
edge-microgateway   1         1         1            1           18h
helloworld          1         1         1            1           1d

A saída indica que uma réplica foi implantada.

Escale a implantação de 1 para quantas réplicas quiser. Neste exemplo, o serviço edge-microgateway é dimensionado.
```
kubectl scale deployment edge-microgateway --replicas=2
```

(Opcional) Se você quiser usar o escalonamento automático, use este comando:

kubectl autoscale deployment edge-microgateway --cpu-percent=50 --min=1 --max=10

Verifique as implantações para verificar se o escalonamento está ativado:

kubectl get deployments

Exemplo de saída:

NAME                DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
edge-microgateway   2         2         2            2           18h
helloworld          1         1         1            1           1d

O estado foi alterado para incluir duas réplicas.

Verifique os pods:

kubectl get pods

Exemplo de saída:

NAME                                 READY     STATUS    RESTARTS   AGE
edge-microgateway-57ccc7776b-g7nrg   1/1       Running   0          18h
edge-microgateway-57ccc7776b-rvfz4   1/1       Running   0          41s
helloworld-6987878fc4-cltc2          1/1       Running   0          1d

A saída mostra que as duas réplicas estão em execução.

Usar namespaces para várias configurações do Edge Microgateway

É possível implantar e configurar várias instâncias de serviços do Edge Microgateway no seu cluster do Kubernetes. Esse caso de uso permite configurar cada instância de microgateway com o próprio conjunto de plug-ins e parâmetros. Exemplo:

O serviço A do Edge Microgateway exige apenas o plug-in de detecção de picos.
O serviço B da microgateway de borda exige o plug-in de cota e oauth, mas não o detecção de picos.

Para resolver esse caso de uso, use os namespaces do Kubernetes. Por exemplo, é possível implantar o serviço A do Edge Microgateway no namespace foo e o serviço B do Edge Microgateway no namespace bar.

No exemplo abaixo, o Edge Microgateway configurado na organização OrgA é implantado como um serviço para o namespace foo usando a opção -n:

kubectl apply -f <(edgemicroctl -org=myorgA -env=test-key=0e3ecea28a64099410594406b30e54439af5265f8 -sec=e3919250bee37c69cb2e5b41170b488e1c1d -conf=/Users/joed/.edgemicro/orgA-test-config.yaml -svc=samples/helloworld/helloworld.yaml) -n foo

Da mesma forma, no exemplo a seguir, o Edge Microgateway configurado na organização OrgB é implantado como um serviço para o namespace bar usando a opção -n:

kubectl apply -f <(edgemicroctl -org=myorgB -env=test-key=0e3ecea28a64099410594406b30e54439af5265f8 -sec=e3919250bee37c69cb2e5b41170b488e1c1d -conf=/Users/joed/.edgemicro/orgB-test-config.yaml -svc=samples/helloworld/helloworld.yaml) -n bar