Configurar o encerramento de TLS no gateway de entrada

Visão geral

Esta página demonstra como configurar uma terminação TLS no gateway de entrada no Cloud Service Mesh para gerenciar o tráfego HTTPS externo para seus serviços. Você vai aprender a configurar o gateway para comunicação segura usando TLS, ativando o acesso criptografado aos seus aplicativos. Esse processo aproveita os recursos do Cloud Service Mesh para expor serviços de forma segura.

Antes de começar

Para concluir as etapas deste documento, você precisa dos seguintes recursos:

  • Um cluster do Kubernetes com o Cloud Service Mesh instalado.

Configurar o ambiente

Execute os comandos a seguir em uma estação de trabalho que possa acessar o cluster que você pretende usar. Verifique se a ferramenta kubectl está configurada para usar o contexto do cluster específico.

  1. Defina as variáveis de ambiente.

    export ASM_INGRESSGATEWAY_NAMESPACE=asm-ingressgateway
export ASM_INGRESSGATEWAY_DEPLOYMENT_NAME=asm-ingressgateway
export ASM_INGRESSGATEWAY_SERVICE_NAME=asm-ingressgateway

  2. O aplicativo foo implantado no cluster. Instale com:

    apiVersion: v1
kind: Service
metadata:
  name: foo
  namespace: foo
spec:
  selector:
    app: test-backend
  ports:
  - port: 8080
    targetPort: 8080
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: foo
  namespace: foo
spec:
  replicas: 2
  selector:
    matchLabels:
      app: test-backend
  template:
    metadata:
      labels:
        app: test-backend
    spec:
      containers:
      - name: whereami
        image: gcr.io/google-samples/whereami:v1.2.23
        ports:
        - containerPort: 8080
EOF

  3. Gerar certificados e chaves

Para proteger seu gateway de entrada, você vai precisar de certificados e chaves TLS. Você pode usar qualquer ferramenta de geração de certificados ou seguir estas etapas usando o openssl para criar as credenciais necessárias.

  • Criar um certificado e uma chave de CA raiz

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

  • Gerar um certificado e uma chave para a entrada

    openssl req -out foo.example.com.csr -newkey rsa:2048 -nodes \
  -keyout foo.example.com.key -subj "/CN=foo.example.com/O=Foo Org"

openssl x509 -req -sha256 -days 365 -CA example.com.crt \
  -CAkey example.com.key -set_serial 0 \
  -in foo.example.com.csr -out foo.example.com.crt

Configurar um gateway de entrada TLS

Antes de seguir as instruções desta seção, você precisa determinar a implementação do plano de controle. Para fazer isso, siga as instruções em Identificar a implementação do plano de controle.

  1. Crie o namespace. Esse namespace é usado para implantar o gateway de entrada.

    kubectl create namespace ${ASM_INGRESSGATEWAY_NAMESPACE}

  2. Aplique o rótulo de injeção padrão ao namespace:

    kubectl label namespace ${ASM_INGRESSGATEWAY_NAMESPACE} \
    istio.io/rev- istio-injection=enabled --overwrite

  3. Aplique o arquivo de manifesto do gateway de entrada.

    kubectl --namespace ${ASM_INGRESSGATEWAY_NAMESPACE} apply --filename https://raw.githubusercontent.com/GoogleCloudPlatform/anthos-service-mesh-samples/main/docs/ingress-gateway-external-lb/ingress-gateway.yaml

    Saída esperada:

    serviceaccount/asm-ingressgateway created
role.rbac.authorization.k8s.io/asm-ingressgateway created
rolebinding.rbac.authorization.k8s.io/asm-ingressgateway created
deployment.apps/asm-ingressgateway created
service/asm-ingressgateway created
poddisruptionbudget.policy/asm-ingressgateway created
horizontalpodautoscaler.autoscaling/asm-ingressgateway created

  4. Armazene as credenciais TLS em um secret do Kubernetes:

    kubectl create -n ${ASM_INGRESSGATEWAY_NAMESPACE} secret tls foo-credential \
  --key=example_certs/foo.example.com.key \
  --cert=example_certs/foo.example.com.crt

  5. Defina o gateway de entrada: crie um recurso de gateway para processar o tráfego HTTPS na porta 443:

    cat <<EOF | kubectl apply -f -
apiVersion: networking.istio.io/v1
kind: Gateway
metadata:
  name: secure-gateway
  namespace: ${ASM_INGRESSGATEWAY_NAMESPACE}
spec:
  selector:
    app: asm-ingressgateway
    istio: ingressgateway
  servers:
  - port:
      number: 443
      name: https
      protocol: HTTPS
    tls:
      mode: SIMPLE
      credentialName: foo-credential
    hosts:
    - "foo.example.com"
EOF

  6. Rotear o tráfego para o serviço foo: defina um VirtualService para direcionar o tráfego para a implantação foo:

    cat <<EOF | kubectl apply -f -
apiVersion: networking.istio.io/v1
kind: VirtualService
metadata:
  name: foo-routing
  namespace: ${ASM_INGRESSGATEWAY_NAMESPACE}
spec:
  hosts:
  - "foo.example.com"
  gateways:
  - secure-gateway
  http:
  - match:
    - uri:
        prefix: /status
    - uri:
        prefix: /delay
    route:
    - destination:
        host: foo
        port:
          number: 8080
EOF

  7. Configure o balanceador de carga externo para se conectar ao gateway de entrada do cluster

  8. Teste a conexão segura: use o curl para verificar a configuração:

    export EXTERNAL_LB_IP_ADDRESS=EXTERNAL_LB_IP_ADDRESS
curl -v -H "Host: foo.example.com" --resolve "foo.example.com:443:$EXTERNAL_LB_IP_ADDRESS" \
  --cacert example_certs/example.com.crt "https://foo.example.com:443/ping"

Substitua EXTERNAL_LB_IP_ADDRESS pelo IP do balanceador de carga externo.

O resultado será assim:

    {
      "cluster_name": "gke-us",
      "host_header": "34.120.175.141",
      "pod_name": "whereami-deployment-954cbf78-mtlpf",
      "pod_name_emoji": "😎",
      "project_id": "my-project",
      "timestamp": "2021-11-29T17:01:59",
      "zone": "us-central1-b"
    }

A seguir