Introdução ao Istio

Introdução ao complemento do Istio gerenciado no IBM Cloud® Kubernetes Service. Nesse conjunto de etapas, você implementa o app de amostra BookInfo para praticar usando vários recursos de malha de serviço do Istio.

Antes de começar, consulte o registro de alterações do complemento “ Istio ” para obter informações sobre a versão.

Etapa 1: Ativar o complemento do Istio

Configure o complemento do Istio gerenciado em seu cluster.

Efetue login na sua conta. If applicable, target the appropriate resource group. Configure o contexto para o seu cluster.

  1. Ative o complemento istio.

    ibmcloud ks cluster addon enable istio --cluster CLUSTER_NAME_OR_ID

  2. Verifique se o complemento Istio gerenciado tem um status de Addon Ready. Observe que pode levar alguns minutos para que o complemento esteja pronto.

    ibmcloud ks cluster addon ls --cluster CLUSTER_NAME_OR_ID

    Saída de exemplo

    Name            Version     Health State   Health Status
istio           1.29       normal         Addon Ready

  3. Também é possível conferir os componentes individuais do complemento para garantir que os pods do Istio sejam implementados.

    kubectl get pods -n istio-system

    kubectl get svc -n istio-system

Para obter mais informações sobre o Istio no IBM Cloud Kubernetes Service, consulte Sobre o complemento do Istio gerenciado.

Etapa 2: Configurar o app de amostra BookInfo

O aplicativo de amostra BookInfo inclui uma configuração básica do Istio para que seja possível experimentar os recursos do Istio imediatamente.

Os quatro microsserviços de BookInfo incluem:

  • productpage chama os microsserviços details e reviews para preencher a página.
  • details contém informações sobre o manual.
  • ratings contém informações de classificação de livro que acompanham uma revisão de livro.
  • reviews contém revisões de livro e chama o microsserviço ratings. O microsserviço reviews tem várias versões:
    • v1 não chama o microsserviço ratings.
    • v2 chama o microsserviço ratings e exibe classificações como 1 a 5 estrelas pretas.
    • v3 chama o microsserviço ratings e exibe classificações como 1 a 5 estrelas vermelhas.

O app BookInfo também já está exposto em um endereço IP público por um gateway do Istio. Para ver a arquitetura do BookInfo, confira a Documentação do Istio.

  1. Instale o BookInfo em seu cluster.

    1. Faça download do pacote do Istio mais recente, que inclui os arquivos de configuração para o app BookInfo.
        curl -L https://istio.io/downloadIstio | ISTIO_VERSION=1.29.5 sh -
    ```
2. Navegue para o diretório do pacote Istio.
```sh {: pre}
    cd istio-1.29.5
    ```
3. Usuários do Linux e do macOS: inclua o cliente `istioctl` em sua variável de sistema `PATH`.
```sh {: pre}
    export PATH=$PWD/bin:$PATH
    ```
4. Rotule o namespace `default` para injeção de sidecar automática. Quaisquer novos pods que são implementados no `default` agora são criados automaticamente com contêineres do sidecar de proxy do Envoy.
```sh {: pre}
    kubectl label namespace default istio-injection=enabled
    ```
5. Implemente o aplicativo BookInfo, o gateway e as regras de destino.
```sh {: pre}
    kubectl apply -f samples/bookinfo/platform/kube/bookinfo.yaml
    kubectl apply -f samples/bookinfo/networking/bookinfo-gateway.yaml
    kubectl apply -f samples/bookinfo/networking/destination-rule-all.yaml
    ```
6. Certifique-se de que os pods de microsserviços do BookInfo estejam `Running`.
```sh {: pre}
    kubectl get pods
    ```
    ```sh {: screen}
    NAME                                     READY     STATUS      RESTARTS   AGE
    details-v1-6865b9b99d-7v9h8              2/2       Running     0          2m
    productpage-v1-f8c8fb8-tbsz9             2/2       Running     0          2m
    ratings-v1-77f657f55d-png6j              2/2       Running     0          2m
    reviews-v1-6b7f6db5c5-fdmbq              2/2       Running     0          2m
    reviews-v2-7ff5966b99-zflkv              2/2       Running     0          2m
    reviews-v3-5df889bcff-nlmjp              2/2       Running     0          2m
    ```

  2. Obtenha o endereço público para o balanceador de carga istio-ingressgateway que expõe o BookInfo.

    • Classic clusters
      1. Configure o endereço IP de ingresso do Istio como uma variável de ambiente.
        export INGRESS_IP=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
      2. Configure a porta de ingresso do Istio como uma variável de ambiente.
        export INGRESS_PORT=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="http2")].port}')
      3. Crie uma variável de ambiente GATEWAY_URL que use o host e a porta de entrada do Istio.
        export GATEWAY_URL=$INGRESS_IP:$INGRESS_PORT
    • Clusters VPC: crie uma variável de ambiente GATEWAY_URL que use o nome do host de entrada do Istio.
        export GATEWAY_URL=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.status.loadBalancer.ingress[0].hostname}')
    ```

  3. Execute curl para a variável GATEWAY_URL para verificar se o app BookInfo está em execução. Uma resposta 200 significa que o app BookInfo está sendo executado adequadamente com o Istio.

    curl -o /dev/null -s -w "%{http_code}\n" http://${GATEWAY_URL}/productpage

  4. Visualize a página da web do BookInfo em um navegador.

    Mac OS ou Linux

    open http://$GATEWAY_URL/productpage

    Windows

    start http://$GATEWAY_URL/productpage

  5. Tente atualizar a página várias vezes. Diferentes versões do round-robin de seção de revisões por meio de nenhuma estrela (v1 de reviews), estrelas pretas (v2) e estrelas vermelhas (v3).

Para obter mais informações sobre como o roteamento funciona no Istio, consulte Entenda o que aconteceu.

Etapa 3: simular um lançamento em fases do BookInfo

Para simular uma liberação de um app, é possível realizar um lançamento em fases da v3 do microsserviço reviews do BookInfo.

Depois de terminar de testar seu app e estiver pronto para começar a direcionar o tráfego em tempo real para ele, será possível realizar lançamentos gradativamente por meio do Istio. Por exemplo, é possível primeiro liberar v3 para 10%dos usuários, depois para 20%dos usuários, e assim por diante.

  1. Configure um serviço virtual para distribuir 0%de tráfego para v1, 90%de tráfego para v2 e 10%de tráfego para v3 de reviews.

    apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: reviews
spec:
  hosts:
  - reviews
  http:
  - route:
    - destination:
        host: reviews
        subset: v1
      weight: 0
    - destination:
        host: reviews
        subset: v2
      weight: 90
    - destination:
        host: reviews
        subset: v3
      weight: 10

    kubectl apply -f <filename>.yaml

  2. Visualize a página da Web BookInfo em um navegador executando open http://$GATEWAY_URL/productpage no Mac OS ou Linux ou executando start http://$GATEWAY_URL/productpage no Windows.

  3. Tente atualizar a página várias vezes. Observe que a página sem estrelas (v1) não é mais mostrada e que a maioria das atualizações da página mostra as estrelas pretas (v2). Raramente a página com estrelas vermelhas (v3) é mostrada.

  4. Mudar a distribuição de tráfego para que todo o tráfego seja enviado apenas para v3. Note que em um cenário real, é possível apresentar lentamente as suas mudanças de versão mudando a distribuição de tráfego primeiro para 80:20, depois 70:30 e assim por diante, até que todo o tráfego seja roteado apenas para a versão mais recente.

    1. Edite o arquivo de configuração para o serviço virtual reviews.
        kubectl edit VirtualService reviews
    ```
2. Mude o `weight` da `v2` para `0` e o `weight` da `v3` para `100`.
3. Salve e feche o arquivo.

  5. Tente atualizar a página do BookInfo várias vezes. Observe que a página com as estrelas pretas (v2) não é mais mostrada e apenas a página com estrelas vermelhas (v3) é mostrada.

  6. Se houver logs de acesso do Envoy ativados: observe que desde que você mudou o arquivo YAML para as revisões VirtualService, não existe nenhum log para solicitações para v2.

    kubectl logs -l app=reviews,version=v2 -c istio-proxy

Etapa 4: monitorar o BookInfo com o IBM Cloud Monitoring

Use um dos painéis predefinidos do Monitoring Istio para monitorar seus microsserviços do BookInfo.

Para implementar agentes de monitoramento no cluster, conclua as etapas a seguir.

  1. Provisione uma instância do IBM Cloud Monitoring.

  2. Configure um agente de monitoramento no cluster.

  3. No Console de monitoramento, clique em Abrir painel para a instância provisionada.

  4. Na IU do Monitoring, clique em Incluir novo painel.

  5. Pesquise “ Istio ” e selecione um dos painéis predefinidos do “ Monitoring ” Istio.

Para obter mais informações sobre a referência a métricas e painéis, o monitoramento de componentes internos do Istio e o monitoramento de implementações A/B do Istio e implementações canárias, confira a postagem do blog Como monitorar o Istio, a malha de serviço do Kubernetes.

Etapa 5: proteger o tráfego no cluster ativando o mTLS

Ative a criptografia para cargas de trabalho em um namespace para atingir o TLS mútuo (mTLS) dentro do cluster. O tráfego roteado pelo Envoy entre os pods no cluster é criptografado com o TLS. O gerenciamento de certificado para o mTLS é manipulado pelo Istio. Para obter mais informações, consulte a documentação Istio mutual TLS.

  1. Crie um arquivo de política de autenticação denominado default.yaml. Essa política tem escopo de namespace definido e configura cargas de trabalho na malha de serviço para aceitar somente solicitações criptografadas com TLS. Observe que nenhuma especificação de targets é incluída porque a política se aplica a todos os serviços na malha nesse namespace.
    apiVersion: "security.istio.io/v1beta1"
kind: "PeerAuthentication"
metadata:
  name: "default"
spec:
  mtls:
    mode: STRICT
  2. Aplique a política de autenticação a um namespace.
    kubectl apply -f default.yaml -n NAMESPACE
  3. Crie um arquivo de regras de destino denominado destination-mtls.yaml. Esta política configura cargas de trabalho mistas de serviço em um namespace para enviar tráfego usando o TLS. Observe que o curinga host: *.local aplica essa regra de destino a todos os serviços na malha.
    apiVersion: "networking.istio.io/v1beta1"
kind: "DestinationRule"
metadata:
  name: "destination-mtls"
spec:
  host: "*.local"
  trafficPolicy:
    tls:
      mode: ISTIO_MUTUAL
  4. Aplique a regra de destino.
    kubectl apply -f destination-mtls.yaml -n NAMESPACE
  5. Se você quiser ativar o recurso “ mTLS ” para cargas de trabalho de service mesh em outros namespaces, repita essas etapas em cada namespace.

As regras de destino também são usadas para motivos que não são de autenticação, como o roteamento do tráfego para diferentes versões de um serviço. Qualquer regra de destino criada para um serviço também deve conter o mesmo bloco do TLS configurado como mode: ISTIO_MUTUAL. Esse bloco evita que a regra substitua as configurações abrangentes de mTLS de malha configuradas nessa seção.