Implementando Istio no EKS
Tags: aws, istio, devops, tutorial
Published: 2022-03-14 12:26:09

O post [Provisionando EKS com Terraform](https://dev.to/aws-builders/provisionando-eks-com-terraform-3e41) e pré-requisito para a implementação de Istio que vou mostrar aqui, caso não tenha seguido ele ainda corre lá e depois volta pra cá

Bom, se chegou na segunda linha e por que já manja de subir um EKS, então bora implementar o Istio nele =D

## Instalando o Istio

Acesse a [página de lançamento do Istio](https://github.com/istio/istio/releases/tag/1.13.1) para baixar o arquivo de instalação do seu sistema operacional ou baixe e extraia a versão mais recente automaticamente para Linux ou macOS com o comando:

```shell
$ curl -L https://istio.io/downloadIstio | sh -
```

Agora vamos para a pasta do Istio:
```shell
$ cd ../istio-1.13.1
```
Exporte o binário istioctl para sua pasta de binários caso você esteja utilizando o Linux ou macOS:
```shell
$ export PATH=$PWD/bin:$PATH
```
Instale o Istio com esse comando:
```shell
$ istioctl install --set profile=demo -y
```
Vamos instalar agora a aplicação httpbin:
```shell
$ kubectl apply -f samples/httpbin/httpbin.yaml
```
Defina o IP e as portas de entrada do seu service mesh:
```shell
$ export INGRESS_HOST=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
export INGRESS_PORT=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="http2")].port}')
export SECURE_INGRESS_PORT=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="https")].port}')
export TCP_INGRESS_PORT=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="tcp")].port}')
```
Em determinados ambientes, o balanceador de carga pode ser exposto usando um nome de host, em vez de um endereço IP. Nesse caso, o EXTERNAL-IP valor do gateway de entrada não será um endereço IP, mas sim um nome de host, e o comando acima não terá definido a INGRESS_HOST variável de ambiente. Use o seguinte comando para corrigir o INGRESS_HOST:
```shell
$ export INGRESS_HOST=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.status.loadBalancer.ingress[0].hostname}')
```
## Configurando o Istio
Crie um Istio Gateway:
```shell
$ kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: Gateway
metadata:
  name: httpbin-gateway
spec:
  selector:
    istio: ingressgateway # use Istio default gateway implementation
  servers:
  - port:
      number: 80
      name: http
      protocol: HTTP
    hosts:
    - "httpbin.example.com"
EOF
```
Configure as rotas para o tráfego que entra por Gateway:
```shell
$ kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: httpbin
spec:
  hosts:
  - "httpbin.example.com"
  gateways:
  - httpbin-gateway
  http:
  - match:
    - uri:
        prefix: /status
    - uri:
        prefix: /delay
    route:
    - destination:
        port:
          number: 8000
        host: httpbin
EOF
```
Defina um gateway de entrada com uma servers:seção configurando as portas 80 e 443. Assegure-se de que esteja definido PASSTHROUGH para tls na porta 443, que instrui o gateway a passar o tráfego de entrada como está, sem encerrar o TLS.
```shell
$ kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: Gateway
metadata:
  name: proxy
spec:
  selector:
    istio: ingressgateway # use istio default ingress gateway
  servers:
  - port:
      number: 80
      name: http
      protocol: HTTP
    hosts:
    - httpbin.org
  - port:
      number: 443
      name: tls
      protocol: TLS
    tls:
      mode: PASSTHROUGH
    hosts:
    - edition.cnn.com
EOF
```
Crie entradas de serviço para httpbin.org e edition.cnn.com serviços para torná-los acessíveis a partir do gateway de entrada:
```shell
$ kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: ServiceEntry
metadata:
  name: httpbin-ext
spec:
  hosts:
  - httpbin.org
  ports:
  - number: 80
    name: http
    protocol: HTTP
  resolution: DNS
  location: MESH_EXTERNAL
---
apiVersion: networking.istio.io/v1alpha3
kind: ServiceEntry
metadata:
  name: cnn
spec:
  hosts:
  - edition.cnn.com
  ports:
  - number: 443
    name: tls
    protocol: TLS
  resolution: DNS
  location: MESH_EXTERNAL
EOF
```
Crie uma entrada de serviço e configure uma regra de destino para o localhost service. Você precisa dessa entrada de serviço na próxima etapa como destino para o tráfego para os serviços externos de aplicativos dentro da malha para bloquear o tráfego de dentro da malha. Neste exemplo, você usa o Istio como um proxy entre aplicativos internos e serviços externos.
```shell
$ kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: ServiceEntry
metadata:
  name: localhost
spec:
  hosts:
  - localhost.local
  location: MESH_EXTERNAL
  ports:
  - number: 80
    name: http
    protocol: HTTP
  - number: 443
    name: tls
    protocol: TLS
  resolution: STATIC
  endpoints:
  - address: 127.0.0.1
---
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: localhost
spec:
  host: localhost.local
  trafficPolicy:
    tls:
      mode: DISABLE
      sni: localhost.local
EOF
```
Crie um serviço virtual para cada serviço externo para configurar o roteamento para ele. Ambos os serviços virtuais incluem o proxy gateway na gateways seção e no match seção para tráfego HTTP e HTTPS.
```shell
$ kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: httpbin
spec:
  hosts:
  - httpbin.org
  gateways:
  - proxy
  - mesh
  http:
  - match:
    - gateways:
      - proxy
      port: 80
      uri:
        prefix: /status
    route:
    - destination:
        host: httpbin.org
        port:
          number: 80
  - match:
    - gateways:
      - mesh
      port: 80
    route:
    - destination:
        host: localhost.local
        port:
          number: 80
---
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: cnn
spec:
  hosts:
  - edition.cnn.com
  gateways:
  - proxy
  - mesh
  tls:
  - match:
    - gateways:
      - proxy
      port: 443
      sni_hosts:
      - edition.cnn.com
    route:
    - destination:
        host: edition.cnn.com
        port:
          number: 443
  - match:
    - gateways:
      - mesh
      port: 443
      sni_hosts:
      - edition.cnn.com
    route:
    - destination:
        host: localhost.local
        port:
          number: 443
EOF
```

## Testando tudo
Acesse o httbin.org service por meio de seu IP e porta de entrada que você armazenou nas variáveis ​​de ambiente $INGRESS_HOSTe de $INGRESS_PORTambiente, respectivamente, durante a etapa anterior. Acesse o /status/418caminho do httpbin.orgserviço que retorna o status HTTP 418 I'm a teapot.
```shell
$ curl $INGRESS_HOST:$INGRESS_PORT/status/418 -Hhost:httpbin.org
```
Se o gateway de entrada do Istio for implantado no istio-system namespace, imprima o log do gateway com o seguinte comando:
```shell
$ kubectl logs -l istio=ingressgateway -c istio-proxy -n istio-system | grep 'httpbin.org'
```
Acesse o edition.cnn.com service por meio do seu gateway de entrada:
```shell
$ curl -s --resolve edition.cnn.com:$SECURE_INGRESS_PORT:$INGRESS_HOST https://edition.cnn.com:$SECURE_INGRESS_PORT | grep -o "<title>.*</title>"
```
Acesse o log do edition.cnn.com service
```shell
$ kubectl logs -l istio=ingressgateway -c istio-proxy -n istio-system | grep 'edition.cnn.com'
```

## Estatísticas de uso visual

Para apresentação visual do fluxo vamos instalar o Kiali, ele é um dos addons que já vem disponível no diretório samples. Para implementar execute o comando em seu terminal
```bash
$ kubectl apply -f samples/addons
```
Espere que os addons sejam instalados. Para verificar se a instalação do Kiali já foi concluída execute esse comando.
```bash
$ kubectl rollout status deployment/kiali -n istio-system
```
Por fim, vamos para o Dashboard Kiali com esse comando
```bash
$ istioctl dashboard Kiali
```
O Kiali será aberto em seu navegador, provavelmente no endereço http://localhost:20001/

Navegue até a aba graph e haverá uma visão gráfica do fluxo que você acabou de montar.

![Kiali Istio](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/4mdkbcie4m5rq4h15nwt.jpeg)

Uma boa prática é utilizar um ferramenta para automatizar essa configuração como Ansible. 

É isso.
Vlw flw.