Trabalhando com o Istio como um Programa Independente

Criando um cluster do OKE

Criar um cluster do OKE.

1. Se você ainda não tiver feito isso, crie um cluster do OKE na tenancy do OCI. Várias opções estão disponíveis para criar um cluster do OKE. A opção mais simples é o assistente de Criação Rápida na console Web.
2. Para acessar o cluster do OKE na sua máquina local, instale kubectl e oci-cli .
3. Acesse o cluster do OKE na linha de comando usando kubectl configurando o arquivo kubeconfig e certifique-se de que kubectl possa acessar o cluster.

Fazendo Download do Istio da Linha de Comando

Siga estas etapas para fazer download do Istio na linha de comando.

1. Faça download do Istio executando o seguinte comando:

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

2. Mover para o diretório do pacote Istio. Por exemplo, se o pacote for istio-1.11.2:

   cd istio-1.11.2

3. Adicione a ferramenta cliente istioctl ao PATH para sua estação de trabalho.

   export PATH=$PWD/bin:$PATH

4. Valide se o cluster atende aos requisitos de instalação do Istio executando a pré-verificação:

   istioctl x precheck

Instalando o Istio com istioctl

istioctl install

Executando o Aplicativo Bookinfo

O projeto Istio fornece o aplicativo Bookinfo como uma forma de demonstrar os recursos do Istio. O aplicativo exibe informações sobre um livro, semelhante a uma única entrada de catálogo de uma livraria on-line. Cada página do livro contém uma descrição do livro, detalhes sobre o livro (ISBN, número de páginas) e algumas resenhas de livros. Para obter mais informações sobre o aplicativo Bookinfo, consulte os documentos Bookinfo aqui.

Como você pode ver no diagrama, o aplicativo Bookinfo é composto por quatro microsserviços.

• Serviço de Página do Produto: Chama os serviços Detalhes e Revisões para criar uma página do produto.
• Serviço de Detalhes: Retorna informações do livro.
• Serviço de Avaliações: Retorna revisões de livros e chama o serviço Classificações.
• Serviço de Classificações: Retorna informações de classificação para uma revisão do livro.

Para instalar e executar o aplicativo Bookinfo, siga estas etapas.

1. Identifique o namespace que hospeda o aplicativo com istio-injection=enabled.

   kubectl label namespace default istio-injection=enabled

2. Disponibilizar a aplicação Bookinfo de amostra.

   kubectl apply -f samples/bookinfo/platform/kube/bookinfo.yaml

3. Verifique se todos os serviços e pods estão em execução.

   kubectl get services
   kubectl get pods

4. Confirme se o aplicativo está em execução enviando um comando curl de um pod.

   kubectl exec "$(kubectl get pod -l app=ratings -o jsonpath='{.items[0].metadata.name}')" -c ratings -- curl -sS productpage:9080/productpage | grep -o "<title>.*</title>"

5. Torne o aplicativo acessível de fora do cluster.

   kubectl apply -f samples/bookinfo/networking/bookinfo-gateway.yaml

6. Verifique se o aplicativo está usando o gateway. Determine INGRESS_HOST e INGRESS_PORT usando estas instruções.

   curl -s "http://${INGRESS_HOST}:${INGRESS_PORT}/productpage" | grep -o "<title>.*</title>"

Além disso, abra o URL http://${INGRESS_HOST}:${INGRESS_PORT}/productpage em um navegador para exibir a página da Web Bookinfo. Atualize a página várias vezes para ver diferentes versões de revisões mostradas na página do produto.

Adicionando Aplicativos de Integração do Istio

O Istio se integra bem a vários aplicativos populares relacionados ao Kubernetes.

Prometheus

O Istio fornece uma instalação básica de amostra para colocar o Prometheus em funcionamento rapidamente.

kubectl apply -f samples/addons/prometheus.yaml

Como alternativa, instale o prometheus e configure para raspar as métricas do Istio.

Para monitoramento em escala de produção usando Prometheus, consulte Usando Prometheus para monitoramento em escala de produção.

Grafana

O Istio fornece uma instalação básica de amostra para colocar o Grafana em funcionamento rapidamente. Todos os painéis do Istio estão incluídos na instalação.

kubectl apply -f samples/addons/grafana.yaml

Como alternativa, instale o Grafana separadamente. Além disso, os painéis pré-configurados do Istio podem ser importados.

Jaeger

O Istio fornece uma instalação básica de amostra para colocar o Jaeger em funcionamento rapidamente.

kubectl apply -f samples/addons/jaeger.yaml

Como alternativa, instale o Jaeger separadamente e configure o Istio para enviar rastreamentos para a implantação do Jaeger.

Zipkin

O Istio fornece uma instalação básica de amostra para ativar e executar rapidamente o zipkin.

kubectl apply -f samples/addons/extras/zipkin.yaml

Como alternativa, instale o zipkin separadamente e configure o Istio para enviar rastreamentos à implantação do zipkin.

Kiali

O Istio fornece uma instalação básica de amostra para colocar o Kiali rapidamente em funcionamento:

kubectl apply -f samples/addons/kiali.yaml
            

Como alternativa, instale e configure o Kiali separadamente.

Consultando Métricas do aplicativo Prometheus para Informações do Livro

Com Prometheus e Istio, os dados de desempenho da Bookinfo são analisados de várias maneiras.

Primeiro, verifique se o Prometheus está instalado.

kubectl -n istio-system get svc prometheus

Inicie a interface de usuário do Prometheus com o seguinte comando:

istioctl dashboard prometheus

Selecione Gráfico à direita de Prometheus no cabeçalho. Para ver alguns dados, gere tráfego para a página do produto usando um browser ou curl. O tráfego é refletido no painel Prometheus.

• Para exibir os resultados, siga as instruções aqui.
• Para obter mais informações sobre consulta ao Prometheus, leia os documentos de consulta do Istio.

Visualizando Métricas para o Aplicativo Bookinfo com o Grafana

A combinação do Prometheus com o Grafana fornece alguns painéis de desempenho interessantes para aplicativos. Para usar os painéis, primeiro verifique se o Prometheus e o Grafana estão instalados.

kubectl -n istio-system get svc prometheus
kubectl -n istio-system get svc grafana

Inicie o painel do Istio Grafana.

istioctl dashboard grafana

Gerenciamento de Dashboards do Grafana

A malha de serviços do Istio oferece seis painéis do Grafana. Os snapshots do painel do Grafana da malha de serviço do Istio são capturados aqui.

Painel de Malha Istio

Painel de Controle de Serviços Istio

Painel da Carga de Trabalho Istio

Istio - Painel de Desempenho

Painel de Controle Istio

Para obter mais informações sobre como criar, configurar e editar painéis, consulte a documentação do Grafana.

Executar rastreamento distribuído usando Jaeger

Use a estrutura de código-fonte aberto Jaeger para executar o rastreamento de aplicativos com o Istio.

1. Ative e configure o rastreamento usando istioctl:

   istioctl install --set meshConfig.enableTracing=true

2. Com o aplicativo Bookinfo implantado, abra a interface do usuário do Jaeger usando istioctl.

   istioctl dashboard jaeger

3. Para gerar rastreamentos, envie solicitações para a página do produto.

   for i in $(seq 1 100); do curl -s -o /dev/null "http://$INGRESS_HOST:$INGRESS_PORT/productpage"; done

Você vê que os traços refletidos no painel Jaeger.

Painel Jaeger

Rastreamento de Aplicativo Jaeger

Executar rastreamento distribuído usando zipkin

Use a estrutura de código aberto zipkin para executar o rastreamento de aplicativos com o Istio.

1. Ative e configure o rastreamento usando istioctl.

   istioctl install --set meshConfig.enableTracing=true

2. Com o aplicativo Bookinfo implantado, abra a IU do zipkin usando istioctl.

   istioctl dashboard zipkin

3. Para gerar rastreamentos, envie solicitações para a página do produto.

   for i in $(seq 1 100); do curl -s -o /dev/null "http://$INGRESS_HOST:$INGRESS_PORT/productpage"; done

Você vê que os rastreamentos refletem no painel do zipkin.

Exemplo de Painel

Executando o Rastreamento Distribuído com o OCI Application Performance Monitoring

O OCI Application Performance Monitoring (APM) se integra a ferramentas do sistema de rastreamento de código-fonte aberto, como Jaeger e zipkin. O APM permite fazer upload de dados de rastreamento no OCI. Para integração com o OCI APM, crie um domínio do APM seguindo as instruções mencionadas aqui. Um domínio do APM é um recurso do OCI que contém os sistemas monitorados pelo APM.

Depois que o domínio for criado, exiba os detalhes do domínio e obtenha o ponto final de upload de dados, a chave privada e a chave pública para construir o URL do Coletor do APM. O URL do coletor do APM é necessário ao configurar rastreadores de código-fonte aberto para comunicação com o serviço do APM. O formato do URL do Coletor requer um URL construído usando o ponto final de upload de dados como o URL base e gera o caminho com base em opções, incluindo valores de nossa chave privada ou pública. O formato está documentado aqui. Com o caminho de URL construído, conecte o URL à configuração do Istio.

Configurando o Istio para Enviar Rastreamentos para o APM

1. Ative o rastreamento com istioctl.

   istioctl install --set meshConfig.defaultConfig.tracing.zipkin.address=aaaabbbb.apm-agt.us-ashburn-1.oci.oraclecloud.com:443

   Observação
   
   O endereço do ponto final de aaaabbbb.apm-agt.us-ashburn-1.oci.oraclecloud.com é um exemplo e não um ponto final real.
2. Configure o Envoy para enviar os rastreamentos zipkin ao APM. Substitua o código em samples/custom-bootstrap/custom-bootstrap.yaml pelo bloco de código a seguir.

   apiVersion: v1
   kind: ConfigMap
   metadata:
     name: istio-custom-bootstrap-config
     namespace: default
   data:
     custom_bootstrap.json: |
       {
           "tracing": {
               "http": {
                   "name": "envoy.tracers.zipkin",
                   "typed_config": {
                       "@type": "type.googleapis.com/envoy.config.trace.v3.ZipkinConfig",
                       "collector_cluster": "aaaabbbb.apm-agt.us-ashburn-1.oci.oraclecloud.com", // [Replace this with data upload endpoint of your apm domain]
                       "collector_endpoint": "/20200101/observations/private-span?dataFormat=zipkin&dataFormatVersion=2&dataKey=2C6YOLQSUZ5Q7IGN", // [Replace with the private datakey of your apm domain. You can also use public datakey but change the observation type to public-span]
                       "collectorEndpointVersion": "HTTP_JSON",
                       "trace_id_128bit": true,
                       "shared_span_context": false
                   }
               }
           },
           "static_resources": {
               "clusters": [{
                   "name": "aaaabbbb.apm-agt.us-ashburn-1.oci.oraclecloud.com", // [Replace this with data upload endpoint of your apm domain:443]
                   "type": "STRICT_DNS",
                   "lb_policy": "ROUND_ROBIN",
                   "load_assignment": {
                       "cluster_name": "aaaabbbb.apm-agt.us-ashburn-1.oci.oraclecloud.com", // [Replace this with data upload endpoint of your apm domain]
                       "endpoints": [{
                           "lb_endpoints": [{
                               "endpoint": {
                                   "address": {
                                       "socket_address": {
                                           "address": "aaaabbbb.apm-agt.us-ashburn-1.oci.oraclecloud.com", // [Replace this with data upload endpoint of your apm domain]
                                           "port_value": 443
                                       }
                                   }
                               }
                           }]
                       }]
                   },
                   "transport_socket": {
                       "name": "envoy.transport_sockets.tls",
                       "typed_config": {
                           "@type": "type.googleapis.com/envoy.extensions.transport_sockets.tls.v3.UpstreamTlsContext",
                           "sni": "aaaabbbb.apm-agt.us-ashburn-1.oci.oraclecloud.com" // [Replace this with data upload endpoint of your apm domain]
                       }
                   }
               }]
           }
       }
   EOF

3. Aplique a configuração personalizada.

   kubectl apply -f samples/custom-bootstrap/custom-bootstrap.yaml

4. Para que todos os nossos serviços no Bookinfo usem essa configuração de bootstrap personalizada, adicione uma anotação sidecar.istio.io/bootstrapOverride com o nome ConfigMap personalizado como o valor. No exemplo a seguir, uma anotação é adicionada para a página do produto em samples/bookinfo/platform/kube/bookinfo.yaml. Adicione uma anotação semelhante a outros serviços.

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: productpage-v1
     labels:
       app: productpage
       version: v1
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: productpage
         version: v1
     template:
       metadata:
         labels:
           app: productpage
           version: v1
         annotations:
           sidecar.istio.io/bootstrapOverride: "istio-custom-bootstrap-config" #[Name of custom configmap]
       spec:
         serviceAccountName: bookinfo-productpage
         containers:
           - name: productpage
             image: docker.io/istio/examples-bookinfo-productpage-v1:1.16.2
             imagePullPolicy: IfNotPresent
             ports:
               - containerPort: 9080
             volumeMounts:
               - name: tmp
                 mountPath: /tmp
             securityContext:
               runAsUser: 1000
         volumes:
           - name: tmp
             emptyDir: {}
   ---

5. Aplique o yaml. Todos os pods reiniciados começam a enviar rastreamentos para o APM.

   kubectl apply -f samples/bookinfo/platform/kube/bookinfo.yaml

6. Para permitir que um gateway de entrada envie rastreamentos, crie um configmap chamado custom-bootstrap.yaml no namespace istio-system:

   apiVersion: v1
   kind: ConfigMap
   metadata:
     name: istio-custom-bootstrap-config
     namespace: istio-system
   data:
     custom_bootstrap.json: |
       {
           "tracing": {
               "http": {
                   "name": "envoy.tracers.zipkin",
                   "typed_config": {
                       "@type": "type.googleapis.com/envoy.config.trace.v3.ZipkinConfig",
                       "collector_cluster": "aaaabbbb.apm-agt.us-ashburn-1.oci.oraclecloud.com", // [Replace this with data upload endpoint of your apm domain]
                       "collector_endpoint": "/20200101/observations/private-span?dataFormat=zipkin&dataFormatVersion=2&dataKey=2C6YOLQSUZ5Q7IGN", // [Replace with the private datakey of your apm domain. You can also use public datakey but change the observation type to public-span]
                       "collectorEndpointVersion": "HTTP_JSON",
                       "trace_id_128bit": true,
                       "shared_span_context": false
                   }
               }
           },
           "static_resources": {
               "clusters": [{
                   "name": "aaaabbbb.apm-agt.us-ashburn-1.oci.oraclecloud.com", // [Replace this with data upload endpoint of your apm domain:443]
                   "type": "STRICT_DNS",
                   "lb_policy": "ROUND_ROBIN",
                   "load_assignment": {
                       "cluster_name": "aaaabbbb.apm-agt.us-ashburn-1.oci.oraclecloud.com", // [Replace this with data upload endpoint of your apm domain]
                       "endpoints": [{
                           "lb_endpoints": [{
                               "endpoint": {
                                   "address": {
                                       "socket_address": {
                                           "address": "aaaabbbb.apm-agt.us-ashburn-1.oci.oraclecloud.com", // [Replace this with data upload endpoint of your apm domain]
                                           "port_value": 443
                                       }
                                   }
                               }
                           }]
                       }]
                   },
                   "transport_socket": {
                       "name": "envoy.transport_sockets.tls",
                       "typed_config": {
                           "@type": "type.googleapis.com/envoy.extensions.transport_sockets.tls.v3.UpstreamTlsContext",
                           "sni": "aaaabbbb.apm-agt.us-ashburn-1.oci.oraclecloud.com" // [Replace this with data upload endpoint of your apm domain]
                       }
                   }
               }]
           }
       }
   EOF

7. Crie um patch chamado gateway-patch.yaml para que o gateway de entrada comece a usar a configuração de inicialização personalizada:

   spec:
     template:
       spec:
         containers:
         - name: istio-proxy
           env:
           - name: ISTIO_BOOTSTRAP_OVERRIDE
             value: /etc/istio/custom-bootstrap/custom_bootstrap.json
           volumeMounts:
           - mountPath: /etc/istio/custom-bootstrap
             name: custom-bootstrap-volume
             readOnly: true
         volumes:
         - configMap:
             name: istio-custom-bootstrap-config
             defaultMode: 420
             optional: false
           name: custom-bootstrap-volume

8. Aplique o patch anterior para o gateway de entrada:

   kubectl --namespace istio-system patch deployment istio-ingressgateway --patch "$(cat gateway-patch.yaml)"

9. Para gerar rastreamentos, envie solicitações para a página do produto.

   for i in $(seq 1 100); do curl -s -o /dev/null "http://$INGRESS_HOST:$INGRESS_PORT/productpage"; done

Você vê que os rastreamentos refletem no painel do APM seguindo as etapas aqui.

Explorador de Rastreamento de Zipkin

Rastreamento de Zipkin

Intervalos de Zipkin

Para ver os intervalos, selecione Início na lista do APM.

Painel de aplicativos Zipkin

O APM fornece funcionalidade para criar painéis de controle e explorar os intervalos gerados com o tempo. Os painéis podem ser criados seguindo as etapas aqui.

Explorador de Métricas do Zipkin

O APM permite monitorar a integridade, a capacidade e o desempenho de seus aplicativos usando métricas, alarmes e notificações. Siga as etapas aqui para configurar métricas.

Observando Logs com o OCI Logging

O OCI Logging é um componente central para analisar e pesquisar entradas de arquivo de log para tenancies no OCI. Os logs de contêiner do Kubernetes dos nós de trabalho do OKE podem ser publicados como logs personalizados no OCI Logging. Siga as etapas descritas aqui para configurar o OCI Logging para ingerir logs de contêiner.

1. Ative o log de acesso do enviado no Istio com istioctl.

   istioctl install --set meshConfig.accessLogFile=/dev/stdout

2. Acesse a página do produto Bookinfo usando um navegador ou curl. Os logs de acesso gerados podem ser exibidos usando o comando kubectl.

   kubectl logs -l app=productpage -c istio-proxy

Se o OCI Logging estiver configurado para o cluster, esses logs poderão ser consultados e analisados usando a página de pesquisa de log da console do OCI.

Pesquisa de Log do OCI

Pesquisa do OCI Logging Expandida

Visualizando Malha Usando Kiali

Verifique se o Kiali está instalado.

kubectl -n istio-system get svc kiali

Abra a UI do Kiali no browser.

istioctl dashboard kiali

Envie algum tráfego para a página do produto.

for i in $(seq 1 100); do curl -s -o /dev/null "http://$INGRESS_HOST:$INGRESS_PORT/productpage"; done

Visualize sua malha em Kiali seguindo a etapa 5 a partir daqui.

Mudança de tráfego

O Istio nos permite migrar o tráfego gradualmente de uma versão de um microsserviço para outra versão usando o recurso de roteamento ponderado do Istio. O exemplo a seguir mostra como configurar para enviar 50% do tráfego para reviews:v1 e 50% para reviews:v3. Depois disso, conclua a migração enviando 100% do tráfego para reviews:v3.

1. Roteie todo o tráfego para a versão v1 de cada microsserviço.

   kubectl apply -f samples/bookinfo/networking/virtual-service-all-v1.yaml

   Para exibir a página Web Bookinfo, abra o URL http://${INGRESS_HOST}:${INGRESS_PORT}/productpage em um browser. Observe que a parte de comentários da página é exibida sem estrelas de classificação, não importa quantas vezes você atualize. O Istio está configurado para rotear todo o tráfego do serviço de revisões para reviews:v1 e esta versão do serviço não acessa o serviço de classificações por estrelas.

2. Transfira 50% do tráfego de reviews:v1 para reviews:v3 com o comando a seguir e aguarde a propagação das novas regras.

   kubectl apply -f samples/bookinfo/networking/virtual-service-reviews-50-v3.yaml

   Atualize o URL /productpage em seu navegador e veja as classificações por estrelas de cor vermelha aproximadamente 50% do tempo. O reviews:v3 acessa o serviço de classificações por estrelas, mas a versão do reviews:v1 não.

3. Agora roteie 100% do tráfego para reviews:v3.

   kubectl apply -f samples/bookinfo/networking/virtual-service-reviews-v3.yaml

4. Atualize o URL /productpage em seu navegador e veja as classificações por estrelas de cor vermelha o tempo todo para cada revisão.

Gerenciando o Roteamento de Solicitações

kubectl apply -f samples/bookinfo/networking/virtual-service-all-v1.yaml

Para exibir a página Web Bookinfo, abra o URL http://${INGRESS_HOST}:${INGRESS_PORT}/productpage em um browser. Observe que a parte de comentários da página é exibida sem estrelas de classificação, não importa quantas vezes você atualize. Como o Istio está configurado para rotear todo o tráfego do serviço de revisões para a versão reviews:v1. Esta versão do serviço não acessa o serviço de classificação por estrelas.

Roteamento com base na Identidade do Usuário

Para rotear com base na identidade do usuário:

1. Altere a configuração da rota para que todo o tráfego de um usuário específico chamado jason seja roteado para reviews:v2. O Istio não tem nenhuma compreensão especial e integrada da identidade do usuário. Neste exemplo, o serviço productpage adiciona um cabeçalho de usuário final personalizado a todas as solicitações HTTP de saída ao serviço de revisões.

   kubectl apply -f samples/bookinfo/networking/virtual-service-reviews-test-v2.yaml

2. Para exibir a página Web Bookinfo e fazer log-in como usuário jason, abra o URL http://${INGRESS_HOST}:${INGRESS_PORT}/productpage em um browser. Atualize o navegador para ver que as classificações por estrelas aparecem ao lado de cada avaliação.

   

3. Abra o URL http://${INGRESS_HOST}:${INGRESS_PORT}/productpage em um browser para exibir a página Web do Bookinfo e fazer log-in como usuário diferente de jason. Atualize o navegador para não ver estrelas para cada revisão.

   

Roteamento baseado na regravação de URL

Neste exemplo, as solicitações HTTP com um caminho que começa com /products ou /bookinfoproductpage são regravadas para /productpage. As solicitações HTTP são enviadas aos pods com productpage em execução na porta 9080. Para obter mais informações sobre a reescrita de URL do Istio, veja aqui.

1. Aplique o seguinte yaml:

   kubectl apply -f - <<EOF
   apiVersion: networking.istio.io/v1beta1
   kind: VirtualService
   metadata:
     name: bookinfo
   spec:
     hosts:
     - "*"
     gateways:
     - bookinfo-gateway
     http:
     - match:
       - uri:
           prefix: /products
       - uri:
           prefix: /bookinfoproductpage
       rewrite:
         uri: /productpage
       route:
       - destination:
           host: productpage
           port:
             number: 9080
   EOF

2. Para exibir a página Web Bookinfo, abra o URL http://${INGRESS_HOST}:${INGRESS_PORT}/products e http://${INGRESS_HOST}:${INGRESS_PORT}/bookinfoproductpage em um browser. Em ambos os casos, uma reescrita é executada antes de encaminhar a solicitação.

   Reescrever /bookproductpage

   

   Regravar/produtos

   
3. Limpe o arquivo yaml para a versão original fornecida pelo Istio e aplique-o.

   kubectl apply -f samples/bookinfo/networking/bookinfo-gateway.yaml

4. Abra o URL http://${INGRESS_HOST}:${INGRESS_PORT}/bookinfoproductpage ou http://${INGRESS_HOST}:${INGRESS_PORT}/products para não ver a página do produto porque o yaml não reescreve a solicitação.

   404 Erro /produtos

   

   Erro 404 /booksproductpage

   

Testando a Resiliência da Rede

O Istio permite que você configure sua instalação para tempos limite de solicitação, injeção de falha e disjuntores. Essas definições permitem gerenciar e testar a tolerância a falhas de aplicativos implantados.

Definindo Time-outs de Solicitação

Tempo limite é o tempo que um proxy do Envoy aguarda respostas de um determinado serviço. O timeout garante que os serviços não aguardem respostas indefinidamente e garante que as chamadas sejam bem-sucedidas ou falhem dentro de um prazo previsível. Para obter mais informações sobre timeouts, veja aqui.

Um timeout para solicitações HTTP pode ser especificado usando o campo timeout da regra de roteamento. Por default, o timeout da solicitação é desativado.

1. Inicialize o roteamento da versão do aplicativo executando o seguinte comando:

   kubectl apply -f samples/bookinfo/networking/virtual-service-all-v1.yaml

2. Roteie solicitações para o serviço reviews:v2, na verdade, uma versão que chama o serviço de classificações:

   kubectl apply -f - <<EOF
   apiVersion: networking.istio.io/v1beta1
   kind: VirtualService
   metadata:
     name: reviews
   spec:
     hosts:
       - reviews
     http:
     - route:
       - destination:
           host: reviews
           subset: v2
   EOF

3. Adicione um atraso de 2 segundos às chamadas ao serviço de classificações:

   kubectl apply -f - <<EOF
   apiVersion: networking.istio.io/v1beta1
   kind: VirtualService
   metadata:
     name: ratings
   spec:
     hosts:
     - ratings
     http:
     - fault:
         delay:
           percent: 100
           fixedDelay: 2s
       route:
       - destination:
           host: ratings
           subset: v1
   EOF

4. Para exibir a página web Bookinfo com estrelas de classificações exibidas, abra o URL http://${INGRESS_HOST}:${INGRESS_PORT}/productpage em um navegador. Um atraso de 2 segundos ocorre sempre que você atualiza a página.
   
5. Adicione meio segundo de timeout de solicitação para chamadas ao serviço de revisões:

   kubectl apply -f - <<EOF
   apiVersion: networking.istio.io/v1beta1
   kind: VirtualService
   metadata:
     name: reviews
   spec:
     hosts:
     - reviews
     http:
     - route:
       - destination:
           host: reviews
           subset: v2
       timeout: 0.5s
   EOF

6. Para exibir a página Web Bookinfo, abra o URL http://${INGRESS_HOST}:${INGRESS_PORT}/productpage em um browser. Observe que a página retorna em cerca de 1 segundo, em vez de 2, e as avaliações não estão disponíveis.
   

O motivo pelo qual a resposta leva 1 segundo, mesmo que o timeout esteja configurado em meio segundo, é porque uma nova tentativa codificada no serviço productpage. O serviço chama o serviço de avaliações expiradas duas vezes antes de retornar.

Além de substituí-los em regras de roteamento, o timeout também poderá ser substituído por solicitação se o aplicativo adicionar um cabeçalho x-envoy-upstream-rq-timeout-ms em solicitações de saída.

Gerenciando a injeção de falha

A injeção de falhas é um método de teste que introduz erros em um sistema para garantir que o sistema resista e se recupere das condições de erro. O Istio permite a injeção de falhas na camada do aplicativo, como códigos de erro HTTP. O Istio injeta dois tipos de falhas, ambas configuradas usando um serviço virtual. Para obter mais informações sobre injeção de falhas, veja aqui.

• Atrasos: Atrasos são falhas de tempo que imitam o aumento da latência da rede ou um serviço upstream sobrecarregado.
• Abortos: abortos são falhas de falha que imitam falhas em serviços upstream. Aborta manifesto na forma de códigos de erro HTTP ou falhas de conexão TCP.

Para testar a injeção de falha, execute o seguinte comando para inicializar o roteamento da versão do aplicativo:

kubectl apply -f samples/bookinfo/networking/virtual-service-all-v1.yaml
kubectl apply -f samples/bookinfo/networking/virtual-service-reviews-test-v2.yaml

Injetando uma Falha de Atraso HTTP

Para injetar uma falha de atraso, siga estas etapas:

• Crie uma regra de injeção de falha para atrasar o tráfego proveniente do usuário jason. O comando a seguir injeta um atraso de 7 segundos entre o reviews:v2 e os microsserviços de classificações para o usuário jason.

  kubectl apply -f samples/bookinfo/networking/virtual-service-ratings-test-delay.yaml

  Observação
  
  O serviço reviews:v2 tem um timeout de conexão com código fixo de 10 segundos para chamadas ao serviço de classificações. Com um atraso de 7 segundos, espere que o fluxo de ponta a ponta continue sem erros.
• Para exibir a página Web Bookinfo, abra o URL http://${INGRESS_HOST}:${INGRESS_PORT}/productpage em um browser.
  

  A página inicial do Bookinfo é carregada sem erros em aproximadamente sete segundos. No entanto, a seção de revisões exibe uma mensagem de erro: Desculpe, as revisões de produtos estão indisponíveis no momento para este livro. Existe um bug no código do aplicativo. O timeout codificado entre o serviço productpage e o serviço reviews resulta em um atraso de 6 segundos, 3 segundos mais 1 repetição. Como resultado, a chamada productpage para reviews expira prematuramente e gera um erro após 6 segundos.

  Para corrigir o bug, aumente o timeout do serviço productpage para reviews ou diminua o timeout de reviews para ratings para menos de 3 segundos.

• Vamos corrigir o bug adicionando um atraso de 2 segundos ao serviço ratings para o usuário jason.

  kubectl apply -f - <<EOF
  apiVersion: networking.istio.io/v1beta1
  kind: VirtualService
  metadata:
    name: ratings
  spec:
    hosts:
    - ratings
    http:
    - match:
      - headers:
          end-user:
            exact: jason
      fault:
        delay:
          percentage:
            value: 100.0
          fixedDelay: 2s
      route:
      - destination:
          host: ratings
          subset: v1
    - route:
      - destination:
          host: ratings
          subset: v1
  EOF

• Agora que o bug foi corrigido, abra o URL http://${INGRESS_HOST}:${INGRESS_PORT}/productpage em um navegador para ver a página do Bookinfo. Efetue sign-in como jason com estrelas de classificações exibidas.
  

Injetando uma Falha de Aborto de HTTP

Siga estas etapas para injetar uma falha de aborto:

1. Crie uma regra de injeção de falha para enviar uma resposta de cancelamento HTTP para o usuário jason:

   kubectl apply -f samples/bookinfo/networking/virtual-service-ratings-test-abort.yaml

2. Para exibir a página Web Bookinfo, abra o URL http://${INGRESS_HOST}:${INGRESS_PORT}/productpage em um browser. Faça log-in como usuário jason. Uma mensagem indica que o serviço ratings está indisponível.
   

   Faça logout do usuário jason ou faça log-in com qualquer outro usuário para não ver nenhuma mensagem de erro.

   

Criando Disjuntores

A quebra de circuito nos permite escrever aplicações que limitam o impacto de falhas, picos de latência e outros efeitos indesejáveis de peculiaridades de rede. Para obter mais informações sobre disjuntores, veja aqui.

1. Crie uma regra de destino para aplicar definições de interrupção de circuito ao chamar o serviço do produto. A regra a seguir define o número máximo de conexões para não ser mais de uma e ter no máximo uma solicitação HTTP pendente. Além disso, as regras configuram hosts para serem verificados a cada 1 segundo. Qualquer host que falha uma vez com um código de erro 5XX é ejetado por 3 minutos. Além disso, 100% dos hosts no pool de balanceamento de carga para o serviço upstream são ejetados.

   kubectl apply -f - <<EOF
   apiVersion: networking.istio.io/v1beta1
   kind: DestinationRule
   metadata:
     name: productpage
   spec:
     host: productpage
     trafficPolicy:
       connectionPool:
         tcp:
           maxConnections: 1
         http:
           http1MaxPendingRequests: 1
           maxRequestsPerConnection: 1
       outlierDetection:
         consecutive5xxErrors: 1
         interval: 1s
         baseEjectionTime: 3m
         maxEjectionPercent: 100
     subsets:
     - name: v1
       labels:
         version: v1
   EOF

2. Roteie todo o tráfego para a versão v1 de cada microsserviço.

   kubectl apply -f samples/bookinfo/networking/virtual-service-all-v1.yaml

3. Crie um cliente para enviar tráfego ao serviço do produto. O Fortio permite que você controle o número de conexões, simultaneidade e atrasos para chamadas HTTP de saída. Se você tiver ativado a injeção automática de sidecar, implante o serviço fortio:

   kubectl apply -f samples/httpbin/sample-client/fortio-deploy.yaml

   Como alternativa, injete manualmente o sidecar antes de implantar o aplicativo fortio.

   kubectl apply -f <(istioctl kube-inject -f samples/httpbin/sample-client/fortio-deploy.yaml)

4. Faça log-in no pod do cliente e use a ferramenta fortio para chamar productpage e verificar se o código de status da resposta é 200 com os comandos a seguir.

   export FORTIO_POD=$(kubectl get pods -l app=fortio -o 'jsonpath={.items[0].metadata.name}')
   kubectl exec "$FORTIO_POD" -c fortio -- /usr/bin/fortio curl http://productpage:9080
   

   É produzida a seguinte saída:

   HTTP/1.1 200 OK
   content-type: text/html; charset=utf-8
   content-length: 1683
   server: envoy
   date: Tue, 07 Sep 2021 11:01:02 GMT
   x-envoy-upstream-service-time: 5

5. Chame o serviço com 2 conexões simultâneas (-c 2) e envie 20 solicitações (-n 20). Curiosamente, 16 solicitações passam e 4 falham.

   kubectl exec "$FORTIO_POD" -c fortio -- /usr/bin/fortio load -c 2 -qps 0 -n 20 -loglevel Warning http://productpage:9080

   O comando produz resultados semelhantes a seguir.

   11:03:43 I logger.go:127> Log level is now 3 Warning (was 2 Info)
   Fortio 1.11.3 running at 0 queries per second, 128->128 procs, for 20 calls: http://productpage:9080
   Starting at max qps with 2 thread(s) [gomax 128] for exactly 20 calls (10 per thread + 0)
   11:03:43 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:03:43 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:03:43 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:03:43 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   Ended after 51.340006ms : 20 calls. qps=389.56
   Aggregated Function Time : count 20 avg 0.0045031997 +/- 0.002036 min 0.000387421 max 0.007704444 sum 0.090063995
   # range, mid point, percentile, count
   >= 0.000387421 <= 0.001 , 0.000693711 , 15.00, 3
   > 0.003 <= 0.004 , 0.0035 , 20.00, 1
   > 0.004 <= 0.005 , 0.0045 , 65.00, 9
   > 0.005 <= 0.006 , 0.0055 , 75.00, 2
   > 0.006 <= 0.007 , 0.0065 , 95.00, 4
   > 0.007 <= 0.00770444 , 0.00735222 , 100.00, 1
   # target 50% 0.00466667
   # target 75% 0.006
   # target 90% 0.00675
   # target 99% 0.00756356
   # target 99.9% 0.00769036
   Sockets used: 5 (for perfect keepalive, would be 2)
   Jitter: false
   Code 200 : 16 (80.0 %)
   Code 503 : 4 (20.0 %)
   Response Header Sizes : count 20 avg 133.6 +/- 66.8 min 0 max 167 sum 2672
   Response Body/Total Sizes : count 20 avg 1528.2 +/- 643.6 min 241 max 1850 sum 30564
   All done 20 calls (plus 0 warmup) 4.503 ms avg, 389.6 qps

6. Aumente o número de conexões simultâneas para 3.

   kubectl exec "$FORTIO_POD" -c fortio -- /usr/bin/fortio load -c 3 -qps 0 -n 30 -loglevel Warning http://productpage:9080

   Apenas 26,7% das solicitações foram bem-sucedidas e a quebra de circuito prende o restante.

   11:10:19 I logger.go:127> Log level is now 3 Warning (was 2 Info)
   Fortio 1.11.3 running at 0 queries per second, 128->128 procs, for 30 calls: http://productpage:9080
   Starting at max qps with 3 thread(s) [gomax 128] for exactly 30 calls (10 per thread + 0)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   11:10:19 W http_client.go:693> Parsed non ok code 503 (HTTP/1.1 503)
   Ended after 28.105508ms : 30 calls. qps=1067.4
   Aggregated Function Time : count 30 avg 0.0024256753 +/- 0.003264 min 0.000261072 max 0.010510116 sum 0.07277026
   # range, mid point, percentile, count
   >= 0.000261072 <= 0.001 , 0.000630536 , 66.67, 20
   > 0.001 <= 0.002 , 0.0015 , 73.33, 2
   > 0.005 <= 0.006 , 0.0055 , 76.67, 1
   > 0.006 <= 0.007 , 0.0065 , 83.33, 2
   > 0.007 <= 0.008 , 0.0075 , 93.33, 3
   > 0.009 <= 0.01 , 0.0095 , 96.67, 1
   > 0.01 <= 0.0105101 , 0.0102551 , 100.00, 1
   # target 50% 0.000805545
   # target 75% 0.0055
   # target 90% 0.00766667
   # target 99% 0.0103571
   # target 99.9% 0.0104948
   Sockets used: 25 (for perfect keepalive, would be 3)
   Jitter: false
   Code 200 : 8 (26.7 %)
   Code 503 : 22 (73.3 %)
   Response Header Sizes : count 30 avg 44.533333 +/- 73.85 min 0 max 167 sum 1336
   Response Body/Total Sizes : count 30 avg 670.06667 +/- 711.5 min 241 max 1850 sum 20102
   All done 30 calls (plus 0 warmup) 2.426 ms avg, 1067.4 qps

7. Consulte as estatísticas de istio-proxy para obter mais informações.

   kubectl exec "$FORTIO_POD" -c istio-proxy -- pilot-agent request GET stats | grep productpage | grep pending

   A quebra de circuito sinaliza 32 chamadas observando a métrica upstream_rq_pending_overflow.

   cluster.outbound|9080|v1|productpage.default.svc.cluster.local.circuit_breakers.default.remaining_pending: 1
   cluster.outbound|9080|v1|productpage.default.svc.cluster.local.circuit_breakers.default.rq_pending_open: 0
   cluster.outbound|9080|v1|productpage.default.svc.cluster.local.circuit_breakers.high.rq_pending_open: 0
   cluster.outbound|9080|v1|productpage.default.svc.cluster.local.upstream_rq_pending_active: 0
   cluster.outbound|9080|v1|productpage.default.svc.cluster.local.upstream_rq_pending_failure_eject: 0
   cluster.outbound|9080|v1|productpage.default.svc.cluster.local.upstream_rq_pending_overflow: 32
   cluster.outbound|9080|v1|productpage.default.svc.cluster.local.upstream_rq_pending_total: 39

8. Limpe o cliente.

   kubectl apply -f samples/bookinfo/networking/destination-rule-all.yaml
   kubectl delete deploy fortio-deploy
   kubectl delete svc fortio

Espelhamento

O espelhamento de tráfego, também chamado de sombreamento, permite que as equipes tragam mudanças para a produção com o mínimo de risco possível. O espelhamento envia uma cópia do tráfego ao vivo para um serviço espelhado. O tráfego espelhado ocorre fora do caminho de solicitação crítica para o serviço principal.

1. Roteie todo o tráfego para a versão v1 de cada microsserviço.

   kubectl apply -f samples/bookinfo/networking/virtual-service-all-v1.yaml

2. Altere a regra de roteamento para espelhar o tráfego para reviews:v2.

   kubectl apply -f - <<EOF
   apiVersion: networking.istio.io/v1beta1
   kind: VirtualService
   metadata:
     name: reviews
   spec:
     hosts:
       - reviews
     http:
     - route:
       - destination:
           host: reviews
           subset: v1
         weight: 100
       mirror:
         host: reviews
         subset: v2
       mirrorPercentage:
         value: 100.0
   EOF

   A regra de roteamento anterior envia 100% do tráfego para reviews:v1 e espelha 100% do mesmo tráfego para o serviço reviews:v2.

   Quando o tráfego é espelhado, as solicitações são enviadas ao serviço espelhado com seus cabeçalhos de Host/Autoridade anexados a -shadow. Por exemplo, as revisões se tornam solicitações reviews-shadow.Mirrored consideradas como "disparar e esquecer". As respostas espelhadas são descartadas.

   Em vez de espelhar todas as solicitações, altere o campo de valor no campo mirrorPercentage para espelhar uma fração do tráfego. Se este campo estiver ausente, todo o tráfego será espelhado.

3. Envie algum tráfego atualizando o url http://${INGRESS_HOST}:${INGRESS_PORT}/productpage em um browser.
4. Logs do serviço reviews:v1. Observação: o serviço v1 não chama o serviço de classificações.
   
5. Logs do serviço espelhado reviews:v2. Observação para o serviço v2, o cabeçalho é anexado a -shadow.
   

Gerenciando Gateways

O gateway descreve um balanceador de carga que opera na borda da malha que recebe conexões HTTP/TCP de entrada ou de saída. As configurações de gateway são aplicadas a proxies Envoy autônomos que estão sendo executados na borda da malha, em vez de proxies Envoy sidecar executados ao lado de suas cargas de trabalho de serviço. O Istio fornece algumas implantações de proxy de gateway pré-configuradas istio-ingressgateway e istio-egressgateway.

istioctl install

O comando implanta o Istio usando as configurações padrão que incluem um gateway. Para obter mais informações, consulte aqui.

Configurando a Entrada usando o Istio Gateway

O gateway de entrada configura portas e protocolos expostos, mas, ao contrário dos Recursos de Entrada do Kubernetes, não inclui nenhuma configuração de roteamento de tráfego. O roteamento de tráfego para tráfego de entrada é configurado usando regras de roteamento Istio. Para obter mais informações sobre a entrada no Istio, veja aqui.

1. Crie um gateway Istio que configura na porta 80 para tráfego HTTP.

   kubectl apply -f - <<EOF
   apiVersion: networking.istio.io/v1beta1
   kind: Gateway
   metadata:
     name: bookinfo-gateway
   spec:
     selector:
       istio: ingressgateway # use istio default controller
     servers:
       - port:
           number: 80
           name: http
           protocol: HTTP
         hosts:
           - "*"
   EOF

2. Configure rotas para tráfego que entra pelo Gateway:

   kubectl apply -f - <<EOF
   apiVersion: networking.istio.io/v1beta1
   kind: VirtualService
   metadata:
     name: bookinfo
   spec:
     hosts:
     - "*"
     gateways:
     - bookinfo-gateway
     http:
     - match:
       - uri:
           exact: /productpage
       - uri:
           prefix: /static
       - uri:
           exact: /login
       - uri:
           exact: /logout
       - uri:
           prefix: /api/v1/products
       route:
       - destination:
           host: productpage
           port:
             number: 9080
   EOF

3. Para implantar o aplicativo Bookinfo, consulte a seção "Executando o Aplicativo Bookinfo" da Página Instalando o Istio e o OKE.
4. Acesse o serviço productpage usando o curl:

   curl -s -I http://$INGRESS_HOST:$INGRESS_PORT/productpage

   O comando produz a seguinte saída:

   HTTP/1.1 200 OK
   content-type: text/html; charset=utf-8
   content-length: 4183
   server: istio-envoy
   date: Tue, 07 Sep 2021 13:48:39 GMT
   x-envoy-upstream-service-time: 36

5. Acesse qualquer outro URL que não tenha sido explicitamente exposto. Você verá um erro HTTP 404.

   curl -s -I http://$INGRESS_HOST:$INGRESS_PORT/any

   O comando produz a seguinte saída:

   HTTP/1.1 404 Not Found
   date: Tue, 07 Sep 2021 13:49:45 GMT
   server: istio-envoy
   transfer-encoding: chunked

6. Para hosts explícitos em gateways, use o flag -H para definir o cabeçalho HTTP do Host. O flag é necessário porque o gateway de entrada e o serviço virtual estão configurados para tratar o host. Por exemplo, seu host é example.com e o nome é especificado nos gateways e no serviço virtual.

   curl -s -I -HHost:example.com http://$INGRESS_HOST:$INGRESS_PORT/productpage

7. Além disso, abra o URL http://${INGRESS_HOST}:${INGRESS_PORT}/productpage em um navegador para exibir a página da Web Bookinfo.

Configurando a Entrada usando o Recurso de Entrada do Kubernetes

O leitor assume que o aplicativo Bookinfo é implantado no cluster. Para implantar o aplicativo Bookinfo, consulte a seção "Executando o Aplicativo Bookinfo" da Página Instalando o Istio e o OKE.

1. Remova o gateway Istio se a configuração já estiver aplicada.

   kubectl delete -f samples/bookinfo/networking/bookinfo-gateway.yaml

2. Crie um recurso de Entrada na porta 80 para tráfego HTTP.

   kubectl apply -f - <<EOF
   apiVersion: networking.k8s.io/v1
   kind: Ingress
   metadata:
     annotations:
       kubernetes.io/ingress.class: istio
     name: ingress
   spec:
     rules:
     - http:
        paths:
        - path: /productpage
          pathType: Prefix
          backend:
             service:
               name: productpage
               port:
                 number: 9080
   EOF

   A anotação kubernetes.io/ingress.class é necessária para informar ao controlador de gateway Istio para tratar esse Ingress.

3. Verifique o acesso ao aplicativo Bookinfo seguindo as instruções da seção anterior.
4. Exclua o recurso e ative o gateway Istio para tarefas adicionais.

   kubectl delete ingress ingress
   kubectl apply -f samples/bookinfo/networking/bookinfo-gateway.yaml

Acessando Serviços Externos com Saída

Por padrão, todo o tráfego de saída de um pod ativado pelo Istio é redirecionado para seu proxy sidecar e o Istio configura o proxy Envoy para passar por solicitações de serviços desconhecidos. O Istio configura o tratamento sidecar de serviços externos por meio de um campo de configuração meshConfig.outboundTrafficPolicy.mode. Se essa opção for definida como:

• ALLOW_ANY (padrão): O proxy Istio permite que chamadas a serviços desconhecidos passem.
• REGISTRY_ONLY: O proxy Istio bloqueia qualquer host sem um serviço HTTP ou uma entrada de serviço definida na malha.

O leitor assume que o aplicativo Bookinfo é implantado no cluster. Caso contrário, siga as etapas para implantar o aplicativo Bookinfo.

Gerenciando a Transferência do Envoy para Serviços Externos

Para ativar a transferência para serviços externos, siga estas etapas.

1. Altere a opção meshConfig.outboundTrafficPolicy.mode para ALLOW_ANY com istioctl.

   istioctl install --set meshConfig.outboundTrafficPolicy.mode=ALLOW_ANY

   Observação
   
   Esta etapa só será necessária se você tiver definido explicitamente a opção como REGISTRY_ONLY durante a instalação.
2. Para confirmar 200 respostas bem-sucedidas, faça uma solicitação para serviços externos pelo SOURCE_POD:

   export SOURCE_POD=$(kubectl get pod -l app=ratings -o jsonpath='{.items..metadata.name}')
   kubectl exec $SOURCE_POD -c ratings -- curl -sI http://httpbin.org/headers | grep "HTTP"

   O comando produz a seguinte saída:

   HTTP/1.1 200 OK

No entanto, a desvantagem com essa abordagem é que o monitoramento e o controle do Istio para o tráfego para serviços externos são perdidos.

Controlando o Acesso a Serviços Externos [Recomendado]

Para configurar o acesso controlado a serviços externos, siga estas etapas:

1. Altere a opção meshConfig.outboundTrafficPolicy.mode para REGISTRY_ONLY. Esta etapa só será necessária se você não tiver definido explicitamente a opção como REGISTRY_ONLY durante a instalação.
2. Siga apenas a etapa 1 da seção "Transferência do Envoy para Serviços Externos". A única alteração a ser feita aqui é substituir ALLOW_ANY por REGISTRY_ONLY.
3. Para verificar se os serviços externos estão bloqueados, faça algumas solicitações para serviços HTTPS externos em SOURCE_POD. As alterações de configuração levam vários segundos para serem propagadas, de modo que conexões bem-sucedidas são possíveis. Aguarde alguns segundos e repita o último comando.

   export SOURCE_POD=$(kubectl get pod -l app=ratings -o jsonpath='{.items..metadata.name}')
   kubectl exec $SOURCE_POD -c ratings -- curl -sI http://httpbin.org/headers | grep "HTTP"

   O comando produz a seguinte saída:

   HTTP/1.1 502 Bad Gateway

4. Crie um ServiceEntry para permitir o acesso a um serviço HTTP externo.

   kubectl apply -f - <<EOF
   apiVersion: networking.istio.io/v1beta1
   kind: ServiceEntry
   metadata:
     name: httpbin-ext
   spec:
     hosts:
     - httpbin.org
     ports:
     - number: 80
       name: http
       protocol: HTTP
     resolution: DNS
     location: MESH_EXTERNAL
   EOF

5. Faça uma solicitação para o serviço HTTP externo em SOURCE_POD. Observe que os cabeçalhos adicionados pelo proxy sidecar do Istio: X-Envoy-Decorator-Operation.

   kubectl exec $SOURCE_POD -c ratings -- curl -sI http://httpbin.org/headers | grep "HTTP"

   O comando produz a seguinte saída:

   HTTP/1.1 200 OK

   Remova o comando grep para ver todos os cabeçalhos.

   kubectl exec $SOURCE_POD -c ratings -- curl -sS http://httpbin.org/headers

   O comando produz a seguinte saída:

   {
     "headers": {
       "Accept": "*/*",
       "Host": "httpbin.org",
       "User-Agent": "curl/7.52.1",
       "X-Amzn-Trace-Id": "Root=1-61384b41-2d3cf8b5571ba7504ab9a834",
       "X-B3-Sampled": "0",
       "X-B3-Spanid": "6983ef0cec914f83",
       "X-B3-Traceid": "d510c4d190cb099d6983ef0cec914f83",
       "X-Envoy-Attempt-Count": "1",
       "X-Envoy-Decorator-Operation": "httpbin.org:80/*",
       "X-Envoy-Peer-Metadata": "ChsKDkFQUF9DT05UQUlORVJTEgkaB3JhdGluZ3MKGgoKQ0xVU1RFUl9JRBIMGgpLdWJlcm5ldGVzChkKDUlTVElPX1ZFUlNJT04SCBoGMS4xMS4xCtQBCgZMQUJFTFMSyQEqxgEKEAoDYXBwEgkaB3JhdGluZ3MKIAoRcG9kLXRlbXBsYXRlLWhhc2gSCxoJYzk5NDdiOTlmCiQKGXNlY3VyaXR5LmlzdGlvLmlvL3Rsc01vZGUSBxoFaXN0aW8KLAofc2VydmljZS5pc3Rpby5pby9jYW5vbmljYWwtbmFtZRIJGgdyYXRpbmdzCisKI3NlcnZpY2UuaXN0aW8uaW8vY2Fub25pY2FsLXJldmlzaW9uEgQaAnYxCg8KB3ZlcnNpb24SBBoCdjEKGgoHTUVTSF9JRBIPGg1jbHVzdGVyLmxvY2FsCiQKBE5BTUUSHBoacmF0aW5ncy12MS1jOTk0N2I5OWYtbGN4bHQKFgoJTkFNRVNQQUNFEgkaB2RlZmF1bHQKTgoFT1dORVISRRpDa3ViZXJuZXRlczovL2FwaXMvYXBwcy92MS9uYW1lc3BhY2VzL2RlZmF1bHQvZGVwbG95bWVudHMvcmF0aW5ncy12MQoXChFQTEFURk9STV9NRVRBREFUQRICKgAKHQoNV09SS0xPQURfTkFNRRIMGgpyYXRpbmdzLXYx",
       "X-Envoy-Peer-Metadata-Id": "sidecar~10.244.0.11~ratings-v1-c9947b99f-lcxlt.default~default.svc.cluster.local"
     }
   }

6. Para acessar chamadas HTTPS, substitua a porta e o protocolo ao criar entradas de serviço.
7. A abordagem adiciona recursos de gerenciamento de tráfego de serviço externo, como timeouts e injeção de falhas. A solicitação a seguir retorna 200 (OK) em aproximadamente cinco segundos.

   kubectl exec $SOURCE_POD -c ratings -- curl http://httpbin.org/delay/5

   Use kubectl para definir um timeout de 3 segundos nas chamadas para o serviço externo httpbin.org:

   kubectl apply -f - <<EOF
   apiVersion: networking.istio.io/v1beta1
   kind: VirtualService
   metadata:
     name: httpbin-ext
   spec:
     hosts:
       - httpbin.org
     http:
     - timeout: 3s
       route:
         - destination:
             host: httpbin.org
           weight: 100
   EOF

   Desta vez, um timeout aparece após 3 segundos. Embora httpbin.org estivesse aguardando cinco segundos, o Istio cortou a solicitação em 3 segundos:

   kubectl exec $SOURCE_POD -c ratings -- curl http://httpbin.org/delay/5

8. Limpe os recursos para tarefas futuras.

   kubectl delete serviceentry httpbin-ext
   kubectl delete virtualservice httpbin-ext --ignore-not-found=true

Direcionando o Acesso a Serviços Externos

Essa abordagem ignora o proxy sidecar do Istio, dando aos serviços acesso direto a qualquer servidor externo. No entanto, configurar o proxy dessa forma requer conhecimento e configuração específicos do provedor de cluster. Semelhante à primeira abordagem, perdemos o monitoramento do acesso a serviços externos e não podemos aplicar os recursos do Istio no tráfego a serviços externos. Siga estas etapas para fornecer acesso direto a serviços externos.

Configurando a Autenticação

O Istio oferece TLS mútuo como uma solução de pilha completa para autenticação de transporte, que é ativada sem exigir alterações no código de serviço.

kubectl apply -f samples/sleep/sleep.yaml
kubectl apply -f samples/httpbin/httpbin.yaml

Por padrão, o Istio executa várias tarefas. O Istio rastreia as cargas de trabalho do servidor migradas para os proxies do Istio. O Istio configura proxies clientes para enviar tráfego TLS mútuo para essas cargas de trabalho automaticamente. O Istio envia tráfego de texto sem formatação para cargas de trabalho sem sidecars.

kubectl exec "$(kubectl get pod -l app=sleep -o jsonpath={.items..metadata.name})" -c sleep -- curl -s http://httpbin.default:8000/headers -s | grep X-Forwarded-Client-Cert | sed 's/Hash=[a-z0-9]*;/Hash=<redacted>;/'

kubectl create ns legacy
kubectl apply -f samples/sleep/sleep.yaml -n legacy
kubectl apply -f samples/httpbin/httpbin.yaml -n legacy

kubectl exec "$(kubectl get pod -l app=sleep -o jsonpath={.items..metadata.name})" -c sleep -- curl http://httpbin.legacy:8000/headers -s | grep X-Forwarded-Client-Cert

kubectl exec "$(kubectl get pod -l app=sleep -n legacy -o jsonpath={.items..metadata.name})" -n legacy -c sleep -- curl http://httpbin.default:8000/headers

kubectl apply -f - <<EOF
apiVersion: security.istio.io/v1beta1
kind: PeerAuthentication
metadata:
  name: "default"
  namespace: "istio-system"
spec:
  mtls:
    mode: STRICT
EOF

kubectl exec "$(kubectl get pod -l app=sleep -n legacy -o jsonpath={.items..metadata.name})" -n legacy -c sleep -- curl http://httpbin.default:8000/headers

kubectl delete peerauthentication -n istio-system default

Além da definição de TLS mútuo global, ela também pode ser definida em um namespace ou nível de carga de trabalho. Siga a documentação do Istio para obter configurações de autenticação detalhadas.

Configurando a Autorização

O Istio permite configurar políticas de autorização para seus aplicativos.

kubectl apply -f - <<EOF
apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: allow-nothing
  namespace: default
spec:
  {}
EOF

Abra a página do produto Bookinfo no seu navegador. Ela mostra o erro "RBAC: access denied" confirmando que a política deny-all está funcionando conforme pretendido.

kubectl apply -f - <<EOF
apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: "productpage-viewer"
  namespace: default
spec:
  selector:
    matchLabels:
      app: productpage
  action: ALLOW
  rules:
  - to:
    - operation:
        methods: ["GET"]
EOF

Você vê a página "Bookinfo Sample", mas o serviço productpage não pode acessar a página de detalhes e revisões.

Adicione as políticas a seguir para conceder acesso à carga de trabalho productpage aos detalhes e verifica cargas de trabalho e verifica o acesso à carga de trabalho à carga de trabalho ratings.

Definir Visualizador de Detalhes

kubectl apply -f - <<EOF
apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: "details-viewer"
  namespace: default
spec:
  selector:
    matchLabels:
      app: details
  action: ALLOW
  rules:
  - from:
    - source:
        principals: ["cluster.local/ns/default/sa/bookinfo-productpage"]
    to:
    - operation:
        methods: ["GET"]
EOF

Definir Visualizador de Revisões

kubectl apply -f - <<EOF
apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: "reviews-viewer"
  namespace: default
spec:
  selector:
    matchLabels:
      app: reviews
  action: ALLOW
  rules:
  - from:
    - source:
        principals: ["cluster.local/ns/default/sa/bookinfo-productpage"]
    to:
    - operation:
        methods: ["GET"]
EOF

Definir Visualizador de Classificações

kubectl apply -f - <<EOF
apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: "ratings-viewer"
  namespace: default
spec:
  selector:
    matchLabels:
      app: ratings
  action: ALLOW
  rules:
  - from:
    - source:
        principals: ["cluster.local/ns/default/sa/bookinfo-reviews"]
    to:
    - operation:
        methods: ["GET"]
EOF

Visualize a página do produto a partir de um navegador sem erros.

Para reverter as políticas aplicadas, informe os comandos a seguir.

kubectl delete authorizationpolicy.security.istio.io/allow-nothing
kubectl delete authorizationpolicy.security.istio.io/productpage-viewer
kubectl delete authorizationpolicy.security.istio.io/details-viewer
kubectl delete authorizationpolicy.security.istio.io/reviews-viewer
kubectl delete authorizationpolicy.security.istio.io/ratings-viewer

Protegendo Gateways com TLS

Podemos expor o aplicativo Bookinfo como um serviço HTTPS seguro usando TLS simples ou mútuo. Para assinar os certificados de seus serviços, crie um certificado raiz e uma chave privada:

openssl req -x509 -sha256 -nodes -days 365 -newkey rsa:2048 -subj '/O=example Inc./CN=example.com' -keyout example.com.key -out example.com.crt

Crie um certificado e uma chave privada para productpage.bookinfo.com.

openssl req -out bookinfo.example.com.csr -newkey rsa:2048 -nodes -keyout bookinfo.example.com.key -subj "/CN=bookinfo.example.com/O=bookinfo organization"
openssl x509 -req -days 365 -CA example.com.crt -CAkey example.com.key -set_serial 0 -in bookinfo.example.com.csr -out bookinfo.example.com.crt

Certifique-se de ter implantado o aplicativo Bookinfo. Crie um segredo para os certificados do gateway de entrada.

kubectl create -n istio-system secret tls bookinfo-credential --key=bookinfo.example.com.key --cert=bookinfo.example.com.crt

Atualize o gateway Bookinfo para incluir uma porta segura.

kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1beta1
kind: Gateway
metadata:
  name: bookinfo-gateway-https
spec:
  selector:
    istio: ingressgateway
  servers:
  - port:
      number: 443
      name: https
      protocol: HTTPS
    tls:
      mode: SIMPLE
      credentialName: bookinfo-credential
    hosts:
    - bookinfo.example.com
EOF

Criar regras de destino Bookinfo se ainda não tiverem sido criadas.

kubectl apply -f samples/bookinfo/networking/destination-rule-all.yaml

Crie um serviço virtual vinculado ao gateway.

kubectl apply -f - <<EOF
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: bookinfo-https
spec:
  hosts:
  - "bookinfo.example.com"
  gateways:
  - bookinfo-gateway-https
  http:
  - route:
    - destination:
        host: productpage
        subset: v1
EOF

Você pode verificar a conexão TLS com o gateway com o seguinte comando curl.

curl -v -HHost:bookinfo.example.com --resolve "bookinfo.example.com:443:$INGRESS_HOST" --cacert example.com.crt "https://bookinfo.example.com/productpage"