Esta página foi traduzida pela API Cloud Translation.

Implantar o Edge Microgateway como serviço

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

Introdução

Neste tópico, explicamos como executar o Edge Microgateway em um cluster do Kubernetes como um serviço independente.

Para mais informações, consulte Integrar o Edge Microgateway com o Kubernetes.

Antes de começar

Conclua as etapas descritas em Pré-requisitos.

Configurar o Edge Microgateway

O comando a seguir configura o Edge Microgateway para sua organização do Apigee e implanta o proxy edgemicro-auth.

Execute o seguinte comando:

edgemicro configure -o [org] -e [env] -u [username]

Em que:

org: o nome da sua organização do Edge (você precisa ser um administrador da organização).
env: um ambiente na sua organização (como teste ou produção).
username: o endereço de e-mail associado à sua conta da Apigee.

Exemplo

edgemicro configure -o docs -e test -u jdoe@example.com

A saída (exemplo mostrado abaixo) é salva no arquivo:

$HOME/.edgemicro/org_name-env_name-config.yaml

current nodejs version is v6.9.1
current edgemicro version is 2.5.25
password:
file doesn't exist, setting up
Give me a minute or two... this can take a while...
App edgemicro-auth deployed.
checking org for existing KVM
KVM already exists in your org
configuring host edgemicroservices.apigee.net for region us-west1

saving configuration information to: /Users/jdoe/.edgemicro/myorg-test-config.yaml

vault info:
 -----BEGIN CERTIFICATE-----
MIICpDCCAYwCCQCV9eBcO9a5WzANBgkqhkiG9w0BAQsFADAUMRIwEAYDVQQDDAls
b2NhbGhvc3QwHhcNMagwODA5MDAzMDEzWhcNMTgwODEwMDAzMDEzWjAUMRIwEAYD
VQQDDBlsb2NhbGhvc3QwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDh
nAHT7JHX/WvWHRFb8FLm53SPIDld5LyPOUfINdEyhSIEeXoOUKg4EPweJPVSC9Vm
Hw4ZMtEqWJM/XsQWvLe8ylRJa5wgmzmFCqAsuzs9+rmc9KvJqjpOh2uRTUf7KKfT
iXL2UEseprcI5g8zNyqKyEf/ecWIwz3AkkPAZebVTsrdDfIDHvkyhhvlAHZAB9kn
GtqP3N8kOlv4KQto9Gr7GYUGUIDugt7gM1F611+RBS+fYRi32GUAq/UQDkhYL8cp
oIJiF7UYkk2+9t9CdOCDuIUCvJioHJQd0xvDpkC9f6LvwjwnCwku+4F2Q63+av5I
mJoZJQPvW5aP53Qkk+kHAgMBAAEwDKYJKoZIhvcNAQELBQADggEBALyUBolXUFN8
1bf268nR+gS8MOFDTxO1bUz+bKuT/g3K1PuNUJTueT+0L1H2OiZUzazAqwn2sqzN
lQuvLg6LjxjlNkqTJGiJvGDcYVq45dv7UyxAZxhqxTxhlQ+Yu5R9pbQnzujezHpH
6gtCoCkSt/QqiJ3YsmsVu5is+HpIJepMt0CyMh5tK9j87hl46QhHklaVfQ3ycMVm
/wNPR/pjizg1FDUeq4nj/7DBVbMf9net/BDaZLeSW1HJ1vcsCXIcSZfQd4QymGFn
8ADrND7ydVjwO/s23soPDTy0g4yLIZvky2tpT8d7YahNqSv2n7sXsLxruzcyCoQ4
w+e3Z3F7IKI=
-----END CERTIFICATE-----

The following credentials are required to start edge micro
  key: 1a3b2754c7f20614817b86e09895825ecc252d34df6c4be21ae24356f09e6eb4
  secret: 16ad2431de73f07f57a6d44048f08d93b63f783bf1f2ac4221182aa7289c7cef

edgemicro configuration complete!

Implantar o Edge Microgateway como um serviço

Execute o comando a seguir para implantar o Edge Microgateway como um serviço no seu cluster do Kubernetes:
```
kubectl apply -f <(edgemicroctl -org=org -env=env -key=edgemicro-key
-sec=edgemicro-secret -conf=file path of org-env-config.yaml)
```
em que:
- org: a organização da Apigee especificada no comando edgemicro configure.
- env: o ambiente especificado no comando edgemicro configure.
- edgemicro-key: a chave retornada pelo comando edgemicro configure.
- edgemicro-secret: o secret retornado do comando edgemicro configure.
- file path of org-env-config.yaml: o caminho para o arquivo de configuração do Edge Micro retornado pelo comando edgemicro configure.
Exemplo:
```
kubectl apply -f <(edgemicroctl -org=jdoe -env=test -key=989cce9d41cac94e72626d906562a1d76a19445f8901b3508858bb064988eccb -sec=ec92b793178de7b7e88e346f55a951e3fdae05e700e3ddea7d63977826379784 -conf=/Users/jdoe/.edgemicro/jdoe-test-config.yaml)
```
Exemplo de saída:
```
config/myorg-test-config.yaml)
service "edge-microgateway" created
deployment "edge-microgateway" created
secret "mgwsecret" created
```
Copie e cole o código a seguir no terminal. O código configura o controlador de entrada para permitir acesso externo ao serviço edge-microgateway. Talvez seja necessário pressionar Enter depois de colar o comando no terminal:
```
cat <<EOF | kubectl apply -f -
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: edge-microgateway-ingress
  annotations:
    kubernetes.io/ingress.class: "nginx"
spec:
  rules:
  - http:
      paths:
      - path: /
        backend:
          serviceName: edge-microgateway
          servicePort: 8000
EOF
```
Se tudo der certo, você vai receber esta saída:
```
ingress "edge-microgateway-ingress" created
```
O Ingress Controller agora está configurado para permitir o acesso externo ao serviço edge-microgateway.

Implantar um serviço de teste

As etapas a seguir implantam um serviço de teste simples no cluster. O controlador de entrada não permite que o serviço seja chamado de fora do cluster. Mais tarde, você vai configurar o Edge Microgateway para chamar o serviço como destino. O controlador de entrada permite acesso externo ao serviço edge-microgateway.

Implante o serviço helloworld de amostra. Como o Ingress não sabe sobre esse serviço, ele não pode ser chamado de fora do cluster.
```
kubectl apply -f samples/helloworld/helloworld-service.yaml
```
Exemplo de saída:
```
service "helloworld" created deployment "helloworld" created
```

Verifique se a implantação foi bem-sucedida. Não há um IP externo para o serviço helloworld. Nas etapas a seguir, você vai configurar o Edge Microgateway para acessar o IP interno do serviço.

kubectl get services -n default

Exemplo de saída:

NAME                TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
edge-microgateway   NodePort    10.35.247.222   <none>        8000:32000/TCP   12m
helloworld          NodePort    10.35.245.103   <none>        8081:30294/TCP   47s
kubernetes          ClusterIP   10.35.240.1     <none>        443/TCP          47m

Configurar o Edge Microgateway como proxy do serviço

Conseguir o IP interno do serviço helloworld e adicioná-lo como destino de um proxy compatível com microgateways. Criar um proxy "compatível com o microgateway" é um requisito padrão do Edge Microgateway.

Consulte também O que você precisa saber sobre proxies compatíveis com microgateways.

Receber o IP interno do serviço de teste

Encontre o IP e a porta do cluster interno para o serviço helloworld:

kubectl get services helloworld

Exemplo de saída:

NAME         TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
helloworld   NodePort   10.55.254.255   <none>        8081:30329/TCP   3m

Copie os valores de CLUSTER-IP e PORT. Por exemplo, no exemplo acima, esses valores são: 10.55.254.255 e 8081. Os valores do seu sistema serão diferentes.

Criar um proxy compatível com microgateway no Edge

Faça login na interface do Edge.
Selecione a mesma organização especificada anteriormente ao configurar o Edge Microgateway.
Selecione Develop > API Proxies no menu de navegação lateral.
Clique em + Proxy. O assistente "Criar um proxy" é aberto.
Na primeira página do assistente, selecione Proxy reverso (mais comum).
Clique em Próxima.
Na página "Detalhes" do assistente, configure o seguinte: Preencha o assistente exatamente como mostrado. Verifique se o nome do proxy tem o prefixo edgemicro_.
1. Nome do proxy: edgemicro_hello
2. Caminho base de proxy: /hello
  
  Importante: na próxima etapa, use o número do IP do cluster e da porta que você recebeu anteriormente. Esse é o IP de destino do proxy.
3. API atual: http://<cluster_ip>:<port>
  
  Por exemplo: http://10.55.254.255:8081
Clique em Próxima.
Na página "Security" do assistente, selecione Pass through (none).
Clique em Próxima.
Na página "Hosts virtuais" do assistente, aceite os padrões.
Clique em Próxima.
Na página "Build" do assistente, revise as configurações do proxy. Verifique se o ambiente test está selecionado.
Clique em Build and Deploy.

Criar um desenvolvedor

Use um desenvolvedor atual para teste ou crie um novo da seguinte maneira:

Selecione Publicar > Desenvolvedores no menu de navegação lateral.
Clique em + Desenvolvedor.
Preencha a caixa de diálogo para criar um desenvolvedor. Use qualquer nome/e-mail de desenvolvedor.

Criar um produto da API

Crie um produto de API conforme descrito abaixo. Você vai adicionar dois proxies ao produto: edgemicro-auth e edgemicro_hello.

Leia mais sobre as opções de configuração de produtos em O que você precisa saber sobre a configuração de produtos da API.

Selecione Publicar > Produtos da API no menu de navegação lateral.
Clique em + Produto da API. A página "Detalhes do produto" vai aparecer.
Preencha a página "Detalhes do produto" da seguinte maneira. Não clique em "Salvar" até receber uma instrução para isso.

Nome hello-world-product

Nome de exibição Edge Micro hello product

Ambiente test

Acesso Public

Tipo de aprovação da chave Automatic
Na metade de baixo da página, clique em + Recurso personalizado.
Defina o recurso como / (um único caractere de barra).
Selecione + Recurso personalizado novamente e adicione o caminho /**.
Na parte de baixo da página, clique em + Proxy de API.
Selecione o proxy chamado edgemicro-auth.
Clique em + Proxy de API novamente.
Selecione o proxy compatível com a microgateway chamado edgemicro_hello.
Clique em Salvar.

Criar um app do desenvolvedor

Selecione Publicar > Apps no menu de navegação lateral.
Clique em + App. A página "Detalhes do app do desenvolvedor" vai aparecer.
Preencha a página do app do desenvolvedor da maneira a seguir. Não salve até receber uma instrução para fazer isso.

Nome hello-world-app

Nome de exibição Edge Micro hello app

Desenvolvedor Selecione o desenvolvedor de teste que você criou ou qualquer outro.
Na seção "Credenciais", clique em + Produto e selecione o produto criado: hello-world-product.
Clique em Salvar.
Você volta à página que lista todos os apps do desenvolvedor.
Selecione o app que você acabou de criar, hello-world-app.
Clique em Mostrar ao lado da chave de cliente.
Copie o valor da chave do consumidor. Esse valor é a chave de API que você vai usar para fazer chamadas de API seguras para /hello.
Aguarde alguns minutos. As mudanças feitas no Apigee Edge levam alguns minutos para serem sincronizadas com a instância do Edge Microgateway implantada no cluster.

Observação: o microgateway do Edge verifica se há mudanças no Apigee Edge a cada 600 segundos (por padrão) e puxa para baixo todas as mudanças de configuração feitas em proxies, produtos de API e apps de desenvolvedor. É possível mudar o padrão de 600s editando o arquivo de configuração da microgateway do Edge. Consulte a documentação do Edge Microgateway para mais detalhes.

Testar o proxy

Acessar o endereço IP de entrada

Com o IP externo para o Ingress, é possível chamar o serviço do Edge Microgateway fora do cluster.

Encontre o endereço IP externo do controlador de entrada:

kubectl get ing -o wide

Exemplo de saída:

NAME                        HOSTS     ADDRESS          PORTS     AGE
edge-microgateway-ingress   *         35.238.249.62    80        37m

Copie o valor ADDRESS do Ingress e exporte-o para uma variável. É possível definir a variável manualmente:

export GATEWAY_IP=external_ip

Exemplo:

export GATEWAY_IP=35.238.249.62

Ou use este comando para definir:

export GATEWAY_IP=$(kubectl describe ing edge-microgateway --namespace default | grep "Address" | cut -d ':' -f2 | tr -d "[:space:]")

Verifique se a variável foi exportada. Exemplo:
```
echo $GATEWAY_IP
```
Exemplo de saída:
```
35.238.249.62
```

Chamar a API

Depois que as mudanças de configuração forem puxadas para o microgateway, tente chamar a API. Você usa o IP do controlador de Ingress (que foi salvo na variável GATEWAY_IP) para chamar a API, porque esse IP permite chamar o proxy de fora do cluster do Kubernetes. O mapeamento do Ingress para o Edge Microgateway foi criado quando você implantou o Edge Microgateway no cluster.

Chamar a API sem uma chave de API. Você vai receber uma mensagem de erro, como mostrado abaixo:
```
curl $GATEWAY_IP:80/hello/
```
Saída esperada:
```
{"error":"missing_authorization","error_description":"Missing Authorization
header"}
```
Se essa mensagem aparecer, talvez seja necessário esperar um pouco mais até que a sincronização seja concluída:
```
{"message":"no match found for /hello/","status":404}
```
Para fazer chamadas de API bem-sucedidas, você precisa da chave de API.
Acesse a chave do cliente no app de desenvolvedor que você criou. Esse valor é a chave da API que você precisa chamar para o proxy de teste:
```
curl -H 'x-api-key:your-edge-api-key' $GATEWAY_IP:80/hello/
```
Exemplo:
```
curl -H "x-api-key:DeX2eEesYAdRJ5Gdbo77nT9uUfJZql19" $GATEWAY_IP:80/hello/
```
Saída:
```
Hello world
```
Se você receber a resposta "Hello world", significa que o Edge Microgateway foi configurado para chamar o serviço helloworld dentro do cluster do Kubernetes.

A seguir

Consulte a seção Tarefas para saber como adicionar plug-ins personalizados, dimensionar implantações, fazer mudanças de configuração e outras tarefas que você pode querer realizar.

Nome	`hello-world-product`
Nome de exibição	`Edge Micro hello product`
Ambiente	`test`
Acesso	`Public`
Tipo de aprovação da chave	`Automatic`

Nome	`hello-world-app`
Nome de exibição	`Edge Micro hello app`
Desenvolvedor	Selecione o desenvolvedor de teste que você criou ou qualquer outro.