Configurar la cancelación de TLS en la pasarela de entrada

Información general

En esta página se muestra cómo configurar una terminación de TLS en la puerta de enlace de entrada de Cloud Service Mesh para gestionar el tráfico HTTPS externo a tus servicios. Aprenderás a configurar la pasarela para que la comunicación sea segura mediante TLS, lo que te permitirá acceder a tus aplicaciones de forma cifrada. Este proceso aprovecha las funciones de Cloud Service Mesh para exponer servicios de forma segura.

Antes de empezar

Para completar los pasos de este documento, necesitas los siguientes recursos:

  • Un clúster de Kubernetes con Cloud Service Mesh instalado.

Configurar un entorno

Ejecuta los siguientes comandos desde una estación de trabajo que pueda acceder al clúster que quieras usar. Asegúrate de que la herramienta kubectl esté configurada para usar el contexto de clúster específico de tu clúster.

  1. Define las variables de entorno.

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

  2. La aplicación foo desplegada en tu clúster. Instálalo con este comando:

    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. Generar certificados y claves

Para proteger tu gateway de entrada, necesitarás certificados y claves TLS. Puedes usar cualquier herramienta de generación de certificados o seguir estos pasos con openssl para crear las credenciales necesarias.

  • Crear un certificado y una clave de AC raíz

    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

  • Generar un certificado y una clave para el ingreso

    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 una pasarela de entrada TLS

Antes de completar las instrucciones de esta sección, debes determinar la implementación de tu plano de control. Para hacerlo, sigue las instrucciones que se indican en Identificar la implementación del plano de control.

  1. Crea el espacio de nombres. Este espacio de nombres se usa para desplegar la puerta de enlace de entrada.

    kubectl create namespace ${ASM_INGRESSGATEWAY_NAMESPACE}

  2. Aplica la etiqueta de inyección predeterminada al espacio de nombres:

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

  3. Aplica el archivo de manifiesto de la pasarela 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

    Resultado esperado:

    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. Almacena las credenciales TLS en un secreto de 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. Define la pasarela de entrada: crea un recurso Gateway para gestionar el tráfico HTTPS en el puerto 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. Dirige el tráfico al servicio foo: define un VirtualService para dirigir el tráfico a la implementación 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. Configura el balanceador de carga externo para que se conecte con la pasarela de entrada del clúster.

  8. Prueba la conexión segura: usa curl para verificar la configuración:

    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"

Sustituye EXTERNAL_LB_IP_ADDRESS por la IP del balanceador de carga externo.

El resultado debería ser similar al siguiente:

    {
      "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"
    }

Siguientes pasos