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. Para uma introdução mais básica sobre como configurar gateways, consulte o guia de gateways. 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 com segurança.

Antes de começar

Você precisa dos seguintes recursos para concluir as etapas deste documento:

  • Um cluster do Kubernetes com o Cloud Service Mesh instalado. Consulte o guia de instalação para saber como instalar o Cloud Service Mesh.

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 CSM_INGRESSGATEWAY_NAMESPACE=CSM_INGRESSGATEWAY_NAMESPACE
export CSM_INGRESSGATEWAY_DEPLOYMENT_NAME=CSM_INGRESSGATEWAY_DEPLOYMENT_NAME
export CSM_INGRESSGATEWAY_SERVICE_NAME=CSM_INGRESSGATEWAY_SERVICE_NAME

  2. Implante o aplicativo foo no cluster. Instale-o com o seguinte yaml:

    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. Gere 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

Armazenar o certificado TLS

Armazene o certificado TLS como um Secret.

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

    kubectl create namespace ${CSM_INGRESSGATEWAY_NAMESPACE}

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

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

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

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

Aplicar o certificado TLS a um gateway

Há duas maneiras de fazer com que o gateway use o certificado TLS recém-criado.

Implantação com credenciais montadas (preferencial)

  1. Copie o manifesto de gateway de entrada padrão para um arquivo local.

    curl https://raw.githubusercontent.com/GoogleCloudPlatform/anthos-service-mesh-samples/main/docs/ingress-gateway-external-lb/ingress-gateway.yaml > ingress-gateway.yaml

  2. Modifique a especificação de implantação em ingress-gateway.yaml para montar a credencial secreta TLS.

    apiVersion: apps/v1
kind: Deployment
...
spec:
  ...
    spec:
        ...
        volumeMounts:
        - name: foo-credential # Add new volume mount specifying mount path.
          mountPath: /etc/secrets/foo-credential 
          readOnly: true
      volumes:
      - name: foo-credential # Point volume mount to the Kubernetes secret holding the TLS certificate and keys.
        secret:
          secretName: foo-credential

    Em seguida, crie os recursos relacionados ao gateway de entrada.

    kubectl --namespace ${CSM_INGRESSGATEWAY_NAMESPACE} apply --filename ingress-gateway.yaml

  3. Defina o gateway de entrada.

    Crie um recurso de gateway para processar o tráfego HTTPS na porta 443 que referencia os segredos montados:

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

Implantação sem credenciais montadas

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

    kubectl --namespace ${CSM_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

  2. 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: ${CSM_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

Como otimizar a implantação

Se você usar a implantação sem credenciais montadas, os pods do gateway de entrada vão verificar periodicamente se as credenciais foram atualizadas. Por padrão, leva até 60 minutos. Para mudar a frequência de pesquisa, defina as variáveis de ambiente CSM_MIN_K8S_SECRET_REFRESH_INTERVAL e CSM_MAX_K8S_SECRET_REFRESH_INTERVAL para a implantação de pods de gateway de entrada.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: asm-ingressgateway
  ...
spec:
  ...
  template:
    ...
    spec:
      containers:
      - name: istio-proxy
        image: auto
        env:
        - name: CSM_MIN_K8S_SECRET_REFRESH_INTERVAL
          value: "15m" # Half of the default minimum interval
        - name: CSM_MAX_K8S_SECRET_REFRESH_INTERVAL
          value: "30m" # Half of the default maximum interval
      ...

Testar o tráfego

  1. Encaminhar o tráfego para o serviço foo.

    Defina um VirtualService para direcionar o tráfego à implantação foo:

    cat <<EOF | kubectl apply -f -
apiVersion: networking.istio.io/v1
kind: VirtualService
metadata:
  name: foo-routing
  namespace: ${CSM_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

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

  3. Teste a conexão segura.

    Use o seguinte comando 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