Proteger serviços do Kubernetes com o Istio

Este tutorial é destinado a usuários e administradores do Kubernetes interessados em usar a malha de serviço do Istio (em inglês) para implantar os serviços do Kubernetes com segurança e ativar a comunicação TLS mútua (mTLS, na sigla em inglês).

Istio e Cloud Service Mesh

O Istio não é um produto com suporte do Google. Recomendamos executar o Cloud Service Mesh gerenciado. Para mais informações, acesse Provisionar o Cloud Service Mesh em um cluster do Autopilot do GKE.

O Cloud Service Mesh oferece os seguintes benefícios de segurança:

  • É possível provisionar o Cloud Service Mesh gerenciado usando a API Fleet sem ferramentas do lado do cliente, como istioctl.
  • O Cloud Service Mesh injeta proxies sidecar automaticamente em cargas de trabalho sem conceder privilégios elevados aos contêineres.
  • É possível visualizar painéis avançados para sua malha e serviços sem nenhuma configuração extra e usar essas métricas para configurar objetivos de nível de serviço (SLOs) e alertas para monitorar a integridade dos aplicativos.
  • O plano de controle do Cloud Service Mesh gerenciado é atualizado automaticamente para garantir que você tenha os patches e recursos de segurança mais recentes.
  • O plano de dados gerenciado do Cloud Service Mesh faz upgrade automaticamente dos proxies sidecar nas cargas de trabalho para que você não precise reiniciar os serviços quando upgrades de proxy e patches de segurança estiverem disponíveis.
  • O Cloud Service Mesh é um produto compatível e pode ser configurado usando APIs Istio de código aberto padrão. Para mais informações, consulte os recursos compatíveis.

Objetivos

Este tutorial inclui as seguintes etapas:

  • Criar um cluster do GKE Autopilot.
  • Instale o Istio usando a ferramenta de linha de comando istioctl.
  • Implante um aplicativo de exemplo para testar a autenticação TLS mútua (mTLS).
  • Configurar o Istio para usar a autenticação mTLS na comunicação serviço a serviço usando um recurso personalizado PeerAuthentication.
  • Verifique a autenticação mTLS usando o painel do Kiali.

Custos

Neste documento, você usará os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Ao concluir as tarefas descritas neste documento, é possível evitar o faturamento contínuo excluindo os recursos criados. Saiba mais em Limpeza.

Antes de começar

O Cloud Shell vem pré-instalado com o software necessário para este tutorial, incluindo kubectl, a gcloud CLI e o Terraform. Se você não usa o Cloud Shell, é necessário instalar a gcloud CLI.

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
  2. Install the Google Cloud CLI.

  3. To initialize the gcloud CLI, run the following command: 

    gcloud init

  4. Create or select a Google Cloud project.

    • Create a Google Cloud project:

      gcloud projects create PROJECT_ID

      Replace PROJECT_ID with a name for the Google Cloud project you are creating.

    • Select the Google Cloud project that you created:

      gcloud config set project PROJECT_ID

      Replace PROJECT_ID with your Google Cloud project name.

  5. Make sure that billing is enabled for your Google Cloud project.

  6. Enable the GKE API: 

    gcloud services enable container.googleapis.com
  7. Install the Google Cloud CLI.

  8. To initialize the gcloud CLI, run the following command: 

    gcloud init

  9. Create or select a Google Cloud project.

    • Create a Google Cloud project:

      gcloud projects create PROJECT_ID

      Replace PROJECT_ID with a name for the Google Cloud project you are creating.

    • Select the Google Cloud project that you created:

      gcloud config set project PROJECT_ID

      Replace PROJECT_ID with your Google Cloud project name.

  10. Make sure that billing is enabled for your Google Cloud project.

  11. Enable the GKE API: 

    gcloud services enable container.googleapis.com

  12. Grant roles to your user account. Run the following command once for each of the following IAM roles: roles/container.clusterAdmin 

    gcloud projects add-iam-policy-binding PROJECT_ID --member="USER_IDENTIFIER" --role=ROLE
    • Replace PROJECT_ID with your project ID.

    • Replace USER_IDENTIFIER with the identifier for your user account. For example, user:myemail@example.com.

    • Replace ROLE with each individual role.

prepare o ambiente

Para configurar o ambiente, siga estas etapas:

  1. Defina as variáveis de ambiente:

    export PROJECT_ID=PROJECT_ID
gcloud config set project $PROJECT_ID
gcloud config set compute/region us-central1

    Substitua PROJECT_ID pelo ID do projeto do Google Cloud.

  2. Clone o repositório do GitHub:

    git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git

  3. Mude para o diretório de trabalho:

    cd kubernetes-engine-samples/service-mesh/istio-tutorial

Crie um cluster do GKE

Ative os recursos do Linux que o Istio exige: NET_RAW e NET_ADMIN. O Autopilot do GKE não permite NET_ADMIN por padrão, mas é possível ativar NET_ADMIN usando o comando --workload-policies=allow-net-admin nas versões 1.27 e mais recentes do GKE:

gcloud container clusters create-auto istio-cluster \
    --location="us-central1" \
    --workload-policies="allow-net-admin"

Para saber mais sobre a segurança do Autopilot do GKE, consulte Configurações de segurança integradas.

Instalar o Istio

É possível instalar o Istio em um cluster do GKE usando o Istioctl (em inglês).

Neste tutorial, você instalará o Istio com o perfil de configuração padrão recomendado para implantações de produção.

  1. Instale o Istio:

    export ISTIO_VERSION=1.20.2
curl -L https://istio.io/downloadIstio | TARGET_ARCH=$(uname -m) sh -

  2. Adicione a ferramenta de linha de comando istioctl ao PATH:

    cd istio-${ISTIO_VERSION}
export PATH=$PWD/bin:$PATH

  3. Instale o Istio no cluster:

    istioctl install --set profile="default" -y

    Essa etapa pode levar alguns minutos.

  4. Aguarde até que os pods do Istio estejam prontos:

    watch kubectl get pods -n istio-system

    O resultado será assim:

    NAME                                    READY   STATUS        RESTARTS   AGE
istio-ingressgateway-5c47bff876-wjm96   1/1     Running       0          2m54s
istiod-5fc7cb65cd-k8cp4                 1/1     Running       0          2m57s

    Quando os pods do Istio forem Running, retorne à linha de comando pressionando Ctrl+C.

Implantar o aplicativo de amostra

Nesta seção, você usará o aplicativo de exemplo Bank of Anthos para criar uma malha de serviço com autenticação mTLS

  1. Adicione um rótulo de namespace que instrua o Istio a ativar a injeção automática de proxies sidecar do Envoy:

    kubectl label namespace default istio-injection=enabled

  2. Implantar o aplicativo de amostra:

    cd ..
git clone https://github.com/GoogleCloudPlatform/bank-of-anthos.git
kubectl apply -f bank-of-anthos/extras/jwt/jwt-secret.yaml
kubectl apply -f bank-of-anthos/kubernetes-manifests/

  3. Aguarde até que o aplicativo esteja pronto:

    watch kubectl get pods

    O resultado será assim:

    NAME                                 READY   STATUS    RESTARTS   AGE
accounts-db-0                        2/2     Running   0          2m16s
balancereader-5c695f78f5-x4wlz       2/2     Running   0          3m8s
contacts-557fc79c5-5d7fg             2/2     Running   0          3m7s
frontend-7dd589c5d7-b4cgq            2/2     Running   0          3m7s
ledger-db-0                          2/2     Running   0          3m6s
ledgerwriter-6497f5cf9b-25c6x        2/2     Running   0          3m5s
loadgenerator-57f6896fd6-lx5df       2/2     Running   0          3m5s
transactionhistory-6c498965f-tl2sk   2/2     Running   0          3m4s
userservice-95f44b65b-mlk2p          2/2     Running   0          3m4s

    Quando os Pods forem Running, retorne para a linha de comando pressionando Ctrl+C.

  4. Analise o seguinte manifesto:

    # Copyright 2020 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

apiVersion: networking.istio.io/v1alpha3
kind: Gateway
metadata:
  name: frontend-gateway
spec:
  selector:
    istio: ingressgateway # use Istio default gateway implementation
  servers:
  - port:
      number: 80
      name: http
      protocol: HTTP
    hosts:
    - "*"
---
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: frontend-ingress
spec:
  hosts:
  - "*"
  gateways:
  - frontend-gateway
  http:
  - route:
    - destination:
        host: frontend
        port:
          number: 80

    Nesse manifesto, descrevemos os recursos de Gateway e VirtualService do Istio que expõem o aplicativo e usam o Istio como controlador de Entrada.

  5. Aplique o manifesto ao cluster:

    kubectl apply -f bank-of-anthos/extras/istio/frontend-ingress.yaml

Configurar mTLS

A autenticação TLS mútua (mTLS, na sigla em inglês) é ativada por padrão no Istio. Isso significa que o Istio monitora as cargas de trabalho do servidor que foram migradas para proxies do Istio e configura automaticamente proxies de cliente para estabelecer conexões mTLS com essas cargas de trabalho. O Istio também configura proxies de cliente para não usar mTLS ao se conectar a cargas de trabalho sem proxies sidecar.

O Istio pode configurar o mTLS para funcionar de três modos:

  • PERMISSIVE: as cargas de trabalho aceitam tráfego mTLS e de texto simples.
  • STRICT: as cargas de trabalho aceitam apenas tráfego mTLS.
  • DISABLE: o mTLS está desativado. Use esse modo se quiser utilizar sua própria solução de segurança.

É possível aplicar a configuração mTLS globalmente, por namespace ou por carga de trabalho. Neste tutorial, você aplicará a configuração por namespace usando o modo mTLS STRICT.

  1. Analise o seguinte manifesto:

    apiVersion: security.istio.io/v1beta1
kind: PeerAuthentication
metadata:
  name: default
spec:
  mtls:
      mode: STRICT

    Este manifesto descreve um recurso personalizado do Istio de autenticação de peering.

  2. Aplique o manifesto ao cluster:

    kubectl apply -f peer-authentication.yaml

Para mais informações sobre o mTLS no Istio, consulte autenticação TLS mútua.

Verificar se o mTLS está ativado

O Kiali é um painel de observabilidade baseado na Web para malha de serviço do Istio que fornece uma visualização gráfica do ambiente de microsserviços, permitindo monitorar e resolver problemas dos aplicativos. É possível usar o Kiali para verificar se a autenticação mTLS está ativada e funcionando corretamente na malha de serviço do Istio. O Kiali requer o Prometheus como fonte de dados de telemetria. Neste tutorial, usamos o Google Cloud Managed Service para Prometheus.

Instalar uma interface de consulta

  1. Crie uma conta de serviço do IAM com o roles/monitoring.viewer para permitir que a interface de consulta acesse as métricas:

    gcloud iam service-accounts create monitoring \
    --display-name="Service account for query interface"
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member "serviceAccount:monitoring@PROJECT_ID.iam.gserviceaccount.com" \
    --role roles/monitoring.viewer
gcloud iam service-accounts add-iam-policy-binding \
  monitoring@PROJECT_ID.iam.gserviceaccount.com \
    --role roles/iam.workloadIdentityUser \
    --member "serviceAccount:PROJECT_ID.svc.id.goog[monitoring/default]"

  2. Crie um namespace do Kubernetes:

    kubectl create namespace monitoring

  3. Anote a conta de serviço padrão do Kubernetes no namespace para configurar a federação de identidade da carga de trabalho para o GKE:

    kubectl annotate serviceaccount -n monitoring default \
    iam.gke.io/gcp-service-account=monitoring@PROJECT_ID.iam.gserviceaccount.com --overwrite

  4. Implante a carga de trabalho da interface de consulta:

    kubectl -n monitoring apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.7.1/examples/frontend.yaml

  5. Analise o seguinte manifesto:

    apiVersion: monitoring.googleapis.com/v1
kind: PodMonitoring
metadata:
  name: istiod
  namespace: istio-system
spec:
  selector:
    matchLabels:
      app: istiod
  endpoints:
  - port: 15014
    path: /metrics
    timeout: 30s
    interval: 60s

    Esse manifesto descreve um recurso PodMonitoring que coleta métricas do Istio e do Envoy Proxy.

  6. Aplique o manifesto ao cluster:

    kubectl apply -f pod-monitorings.yaml

  7. Receba um link para o aplicativo de amostra:

    INGRESS_HOST=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
echo "http://$INGRESS_HOST"

  8. Abra o link para ver o aplicativo de amostra. Faça login com o nome de usuário e a senha padrão para gerar tráfego entre os microsserviços.

Instalar o Kiali

Recomendamos que você instale o Kiali usando o operador Kiali.

  1. Instale o operador Kiali:

    helm repo add kiali https://kiali.org/helm-charts
helm repo update
helm install \
    --namespace kiali-operator \
    --create-namespace \
    kiali-operator \
    kiali/kiali-operator

  2. Analise o seguinte manifesto:

    apiVersion: kiali.io/v1alpha1
kind: Kiali
metadata:
  name: kiali
  namespace: istio-system
spec:
  deployment:
    namespace: istio-system
  auth:
    strategy: anonymous
  external_services:
    custom_dashboards:
      prometheus:
        url: "http://frontend.monitoring:9090/"
        auth:
          type: none
    prometheus:
      url: "http://frontend.monitoring:9090/"
      auth:
        type: none
    tracing:
      enabled: false
    grafana:
      enabled: false

    Esse manifesto descreve um recurso personalizado de operador que define o servidor Kiali.

  3. Aplique o manifesto ao cluster:

    kubectl apply -f kiali.yaml

  4. Aguarde até que o servidor do Kiali esteja pronto:

    watch kubectl get pods -n istio-system

    O resultado será assim:

    NAME                                    READY   STATUS    RESTARTS   AGE
istio-ingressgateway-6845466857-92zp8   1/1     Running   0          9m11s
istiod-6b47d84cf-4cqlt                  1/1     Running   0          12m

    Quando os Pods forem Running, retorne para a linha de comando pressionando Ctrl+C.

  5. Configure o encaminhamento de portas no serviço do servidor Kiali para acessar o painel:

    kubectl -n istio-system port-forward svc/kiali 8080:20001

  6. Abra a Visualização da Web. No Kiali, acesse a seção Graph e selecione a opção Security no menu suspenso Display. Essa visualização mostra o estado de segurança de cada nó no gráfico. Os nós com um selo mTLS ativado indicam que a mTLS está ativada para esse serviço, e os nós sem o selo indicam que a mTLS não está ativada.

Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto que os contém ou mantenha o projeto e exclua os recursos individuais.

Exclua o projeto

    Delete a Google Cloud project:

    gcloud projects delete PROJECT_ID

Excluir recursos individuais

Se você usou um projeto existente e não quer excluí-lo, exclua os recursos individuais.

  1. Exclua o Kiali:

    kubectl -n istio-system delete kiali kiali
helm uninstall --namespace kiali-operator kiali-operator

  2. Exclua os recursos de monitoramento:

    kubectl -n monitoring delete -f https://raw.githubusercontent.com/GoogleCloudPlatform/prometheus-engine/v0.7.1/examples/frontend.yaml

  3. Exclua o aplicativo de amostra:

    kubectl delete -f bank-of-anthos/extras/istio/frontend-ingress.yaml
kubectl delete -f bank-of-anthos/kubernetes-manifests

  4. Desinstale o Istio:

    istioctl uninstall --purge -y

  5. Exclua o cluster do GKE:

    gcloud container clusters delete --region us-central1 istio-cluster --quiet

A seguir