Proteger serviços do Kubernetes com o Istio

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

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.