Crear un Service y un Ingress

En este documento, se muestra cómo crear un objeto Ingress de Kubernetes en un clúster de usuario de Google Distributed Cloud. Un Ingress está asociado con uno o más servicios, cada uno de los cuales está asociado con un conjunto de pods.

Antes de comenzar

Obtén una conexión SSH a tu estación de trabajo de administrador:

Crear una implementación

Este es un manifiesto para una implementación:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-deployment
spec:
  selector:
    matchLabels:
      greeting: hello
  replicas: 3
  template:
    metadata:
      labels:
        greeting: hello
    spec:
      containers:
      - name: hello-world
        image: "gcr.io/google-samples/hello-app:2.0"
        env:
        - name: "PORT"
          value: "50000"
      - name: hello-kubernetes
        image: "gcr.io/google-samples/node-hello:1.0"
        env:
        - name: "PORT"
          value: "8080"

A los fines de este ejercicio, estos son los puntos importantes que debes comprender sobre el manifiesto de Deployment:

  • Cada Pod que pertenece al Deployment tiene la etiqueta greeting: hello.

  • Cada Pod tiene dos contenedores.

  • En los campos env, se especifica que los contenedores hello-app escuchan en el puerto TCP 50000, y los contenedores node-hello escuchan en el puerto TCP 8080. En el caso de hello-app, puedes ver el efecto de la variable de entorno PORT si observas el código fuente de hello-app.

Copia el manifiesto en un archivo llamado hello-deployment.yaml y crea la implementación:

kubectl apply --kubeconfig USER_CLUSTER_KUBECONFIG -f hello-deployment.yaml

En el ejemplo anterior, USER_CLUSTER_KUBECONFIG es la ruta de acceso del archivo kubeconfig del clúster de usuario.

Expón tu Deployment con un Service

A fin de proporcionar una forma estable para que los clientes envíen solicitudes a los Pods de tu Deployment, crea un Service.

Este es un manifiesto para un Service que expone tu Deployment a los clientes dentro del clúster:

apiVersion: v1
kind: Service
metadata:
  name: hello-service
spec:
  type: ClusterIP
  selector:
    greeting: hello
  ports:
  - name: world-port
    protocol: TCP
    port: 60000
    targetPort: 50000
  - name: kubernetes-port
    protocol: TCP
    port: 60001
    targetPort: 8080

Copia el manifiesto en un archivo llamado hello-service.yaml y crea el Service:

kubectl apply --kubeconfig USER_CLUSTER_KUBECONFIG -f hello-service.yaml

Observa el Service:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG get service hello-service --output yaml

El resultado muestra el valor de clusterIP que se le dio al Service. Por ejemplo:

apiVersion: v1
kind: Service
metadata:
  annotations:
    ...
spec:
  clusterIP: 10.96.14.249
  clusterIPs:
  - 10.96.14.249
  ipFamilies:
  - IPv4
  ipFamilyPolicy: SingleStack
  ports:
  - name: world-port
    port: 60000
    protocol: TCP
    targetPort: 50000
  - name: kubernetes-port
    port: 60001
    protocol: TCP
    targetPort: 8080
  selector:
    greeting: hello
  sessionAffinity: None
  type: ClusterIP
status:
  loadBalancer: {}

En el resultado anterior, el campo ports es un array de objetos ServicePort de Kubernetes: uno llamado world-port y otro llamado kubernetes-port.

Estas son las formas en que un cliente puede llamar al Service:

  • Mediante world-port: Un cliente que se ejecuta en uno de los nodos del clúster envía una solicitud a clusterIP en port. En este ejemplo, 10.96.14.249:60000: La solicitud se reenvía a un Pod miembro en targetPort. En este ejemplo, POD_IP_ADDRESS: 50000.

  • Mediante kubernetes-port: Un cliente que se ejecuta en uno de los nodos del clúster envía una solicitud a clusterIP en port. En este ejemplo, 10.96.14.249:60001: La solicitud se reenvía a un Pod miembro en targetPort. En este ejemplo, POD_IP_ADDRESS:8080.

Componentes de Ingress

Estos son algunos de los componentes del clúster relacionados con la entrada:

  • El Deployment istio-ingress. Este es el proxy de entrada. El proxy de entrada reenvía el tráfico a los servicios internos según las reglas especificadas en un objeto Ingress.

  • El servicio de istio-ingress. Este Service expone la implementación de istio-ingress.

  • El Deployment istiod. Este es el controlador de entrada. El controlador de entrada observa la creación de objetos de Ingress y configura el proxy de entrada según corresponda.

Crea un Ingress

Este es el manifiesto de un Ingress:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-ingress
spec:
  rules:
  - http:
      paths:
      - path: /greet-the-world
        pathType: Exact
        backend:
          service:
            name: hello-service
            port:
              number: 60000
      - path: /greet-kubernetes
        pathType: Exact
        backend:
          service:
            name: hello-service
            port:
              number: 60001

Copia el manifiesto en un archivo llamado my-ingress.yaml y crea el Ingress:

kubectl apply --kubeconfig USER_CLUSTER_KUBECONFIG -f my-ingress.yaml

Cuando creas un clúster de usuario, especificas un valor para loadbalancer.ingressVip en el archivo de configuración del clúster. Esta dirección IP se configura en el balanceador de cargas del clúster. Cuando creas un Ingress, se le proporciona este mismo VIP como su dirección IP externa.

Cuando un cliente envía una solicitud a tu VIP de entrada del clúster de usuario, la solicitud se enruta al balanceador de cargas. El balanceador de cargas usa el servicio de istio-ingress para reenviar la solicitud al proxy de entrada, que se ejecuta en el clúster de usuario. El proxy de entrada está configurado para reenviar la solicitud a diferentes backends según la ruta en la URL de la solicitud.

La ruta /greet-the-world

En el manifiesto de Ingress, puedes ver una regla que indica que la ruta /greet-the-world está asociada con serviceName: hello-service y servicePort: 60000. Recuerda que 60000 es el valor de port en la sección world-port del Service hello-service.

- name: world-port
    port: 60000
    protocol: TCP
    targetPort: 50000

El Service de entrada reenvía la solicitud a clusterIP:50000. Luego, la solicitud va a uno de los Pods miembros del servicio hello-service. El contenedor, en ese Pod, que escucha en el puerto 50000 muestra un mensaje Hello World!.

La ruta /greet-kubernetes

En el manifiesto de Ingress, puedes ver una regla que indica que la ruta /greet-kubernetes está asociada con serviceName: hello-service y servicePort: 60001. Recuerda que 60001 es el valor de port en la sección kubernetes-port del Service hello-service.

- name: kubernetes-port
    port: 60001
    protocol: TCP
    targetPort: 8080

El Service de entrada reenvía la solicitud a clusterIP: 8080. Luego, la solicitud va a uno de los Pods miembros del servicio hello-service. El contenedor, en ese Pod, que escucha en el puerto 8080 muestra un mensaje Hello Kubernetes!.

Prueba el Ingress:

Prueba el Ingress con la ruta /greet-the-world:

curl USER_CLUSTER_INGRESS_VIP/greet-the-world

Reemplaza USER_CLUSTER_INGRESS_VIP por la dirección IP externa del Ingress.

El resultado muestra un mensaje Hello, world!:

Hello, world!
Version: 2.0.0
Hostname: ...

Prueba el Ingress con la ruta /greet-kubernetes:

curl USER_CLUSTER_INGRESS_VIP/greet-kubernetes

El resultado muestra un mensaje Hello, Kubernetes!:

Hello Kubernetes!

Configura HTTPS para Ingress

Si deseas aceptar solicitudes HTTPS de los clientes, el proxy de entrada debe contar con un certificado para que pueda demostrar su identidad a los clientes. Este proxy también debe tener una clave privada para completar el protocolo de enlace HTTPS.

En el siguiente ejemplo, se usan estas entidades:

  • Proxy de Ingress: participa en el protocolo de enlace HTTPS y, luego, reenvía los paquetes a los pods miembros del servicio hello-service.

  • Dominio para el servicio hello-service: altostrat.com en la organización de ejemplo

Lleva a cabo los pasos siguientes:

  1. Crea un certificado raíz y una clave privada. En este ejemplo, se usa una autoridad de certificación raíz de root.ca.example.com en la organización de ejemplo de CA raíz.

    openssl req -x509 -sha256 -nodes -days 365 -newkey rsa:2048 -subj '/O=Root CA Example Inc./CN=root.ca.example.com' -keyout root-ca.key -out root-ca.crt

  2. Crea una solicitud de firma de certificado:

    openssl req -out server.csr -newkey rsa:2048 -nodes -keyout server.key -subj "/CN=altostrat.com/O=Example Org"

  3. Crea un certificado de entrega para el proxy de entrada.

    openssl x509 -req -days 365 -CA root-ca.crt -CAkey root-ca.key -set_serial 0 -in server.csr -out server.crt

    Ya creaste los siguientes certificados y claves:

    • root-ca.crt: Certificado para la CA raíz
    • root-ca.key: Clave privada para la CA raíz
    • server.crt: Certificado de entrega para el proxy de entrada
    • server.key: Clave privada para el proxy de entrada

  4. Crea un secreto de Kubernetes que contenga la clave y el certificado de entrega.

    kubectl create secret tls example-server-creds --key=server.key --cert=server.crt --namespace gke-system

    El secreto que se obtiene como resultado se llama example-server-creds.

Crea una implementación y un servicio

Si creaste una implementación y un servicio en la parte HTTP de esta guía, déjalos en su lugar. De lo contrario, créalos ahora siguiendo los pasos descritos para HTTP.

Crea un Ingress

Si creaste un Ingress en la parte HTTP antes, bórralo antes de continuar.

Borra el Ingress:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG delete ingress my-ingress

Para controlar el tráfico del Service que creaste antes, crea un nuevo Ingress con una sección tls. Esto habilitará HTTPS entre los clientes y el proxy de entrada.

Este es el manifiesto de un Ingress:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-ingress-2
spec:
  tls:
  - hosts:
    - altostrat.com
    secretName: example-server-creds
  rules:
  - host: altostrat.com
    http:
      paths:
      - path: /greet-the-world
        pathType: Exact
        backend:
          service:
            name: hello-service
            port:
              number: 60000
      - path: /greet-kubernetes
        pathType: Exact
        backend:
          service:
            name: hello-service
            port:
              number: 60001

Guarda el manifiesto en un archivo llamado my-ingress-2.yaml y crea el Ingress.

kubectl apply --kubeconfig USER_CLUSTER_KUBECONFIG -f my-ingress-2.yaml

Confirma mediante una prueba.

  • Prueba la ruta /greet-the-world:

    curl -v --resolve altostrat.com:443:USER_CLUSTER_INGRESS_VIP https://altostrat.com/greet-the-world --cacert root-ca.crt

    Resultado:

    Hello, world!
Version: 2.0.0
Hostname: hello-deployment-5ff7f68854-wqzp7

  • Prueba la ruta /greet-kubernetes:

    curl -v --resolve altostrat.com:443:USER_CLUSTER_INGRESS_VIP https://altostrat.com/greet-kubernetes --cacert root-ca.crt

    Resultado:

    Hello Kubernetes!

Realice una limpieza

Borra el Ingress:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG delete ingress INGRESS_NAME

Reemplaza INGRESS_NAME por el nombre del Ingress, como my-ingress o my-ingress-2.

Borra el Service:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG delete service hello-service

Borra el Deployment:

kubectl --kubeconfig USER_CLUSTER_KUBECONFIG delete deployment hello-deployment