Crear un Service y un Ingress

En este documento, se muestra cómo crear un objeto Ingress de Kubernetes en un clúster independiente, de usuario o híbrido para Google Distributed Cloud. Un Ingress se asocia con uno o más objetos Service, cada uno de los cuales está asociado con un conjunto de Pods.

Crear una implementación

Sigue estos pasos para crear una implementación:

1. Crea un manifiesto de Deployment:

   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"
   

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

2. Copia el manifiesto en un archivo llamado hello-deployment.yaml.

3. Crea el Deployment:

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

   Reemplaza CLUSTER_KUBECONFIG por el nombre del archivo kubeconfig del clúster.

Expón tu Deployment con un Service

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

1. Crea un manifiesto de Service que exponga 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
   

2. Copia el manifiesto en un archivo llamado hello-service.yaml.

3. Crea el objeto Service

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

   Reemplaza CLUSTER_KUBECONFIG por el nombre del archivo kubeconfig del clúster.

4. Observa el Service:

   kubectl --kubeconfig 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: uno llamado world-port y otro llamado kubernetes-port. Para obtener más información sobre los campos de servicio, consulta ServiceSpec en la documentación de Kubernetes.

   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 (como 10.96.14.249:60000). El controlador de entrada reenvía la solicitud a un pod miembro en targetPort (como POD_IP_ADDRESS:50000, donde POD_IP_ADDRESS es la dirección IP de un pod miembro).

   • Mediante kubernetes-port: Un cliente que se ejecuta en uno de los nodos del clúster envía una solicitud a clusterIP en port (10.96.14.249:60001). El controlador de entrada reenvía la solicitud a un Pod miembro en targetPort (POD_IP_ADDRESS:8080).

Componentes de Ingress

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

Nota: Los componentes de Istio preinstalados en Google Distributed Cloud solo admiten la entrada. Estos componentes no están diseñados para proporcionar capacidades generales de malla de servicios. Para obtener información sobre la configuración de una malla de servicios completamente funcional, consulta Configuración en la documentación de Istio o Configura una malla de varios clústeres fuera deGoogle Cloud en la documentación de Cloud Service Mesh.

• 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 Ingress detecta la creación de los objetos Ingress y configura el proxy de entrada según corresponda.

Todos estos componentes en el clúster de Istio se instalan en el espacio de nombres gke-system. Este espacio de nombres no entra en conflicto con una instalación completa de Istio/Cloud Service Mesh.

Crea un Ingress

Sigue estos pasos para crear un Ingress:

1. Crea un manifiesto de 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
   

2. Copia el manifiesto en un archivo llamado my-ingress.yaml.

3. Crea el Ingress:

   kubectl apply --kubeconfig 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 reenvía 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:

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

   curl CLUSTER_INGRESS_VIP/greet-the-world
   

   Reemplaza 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: ...
   

2. Prueba el Ingress con la ruta /greet-kubernetes:

   curl CLUSTER_INGRESS_VIP/greet-kubernetes
   

   El resultado muestra un mensaje Hello, Kubernetes!:

   Hello Kubernetes!
   

Inhabilita el Ingress agrupado

La capacidad de Ingress incluida con Google Distributed Cloud solo admite capacidades de entrada. Puedes elegir integrarlo en Istio o en Cloud Service Mesh. Estos productos ofrecen los beneficios adicionales de una malla de servicios completamente funcional, como la seguridad mutua en la capa de transporte (mTLS), la capacidad de administrar la autenticación entre servicios y la observabilidad de las cargas de trabajo. Si te integras a Istio o a Cloud Service Mesh, te recomendamos que inhabilites la capacidad de Ingress empaquetada.

Puedes habilitar o inhabilitar el Ingress agrupado con el campo spec.clusterNetwork.bundledIngress en el archivo de configuración del clúster. Este campo solo está disponible para los clústeres de la versión 1.13.0 y posteriores. El campo bundledIngress predeterminado es true y no está presente en el archivo de configuración del clúster generado. Este campo es mutable y se puede cambiar cuando crees o actualices un clúster de la versión 1.13.0 o superior.

• Para inhabilitar la capacidad de Ingress agrupada, agrega el campo bundledIngress a la sección clusterNetwork del archivo de configuración del clúster y establece su valor en "false", como se muestra en el siguiente ejemplo:

  apiVersion: v1
  kind: Namespace
  metadata:
    name: cluster-hybrid-basic
  ---
  apiVersion: baremetal.cluster.gke.io/v1
  kind: Cluster
  metadata:
    name: hybrid-basic
    namespace: cluster-hybrid-basic
  spec:
    type: hybrid
    profile: default
    anthosBareMetalVersion: 1.13.0
    gkeConnect:
      projectID: project-fleet
    controlPlane:
      nodePoolSpec:
        nodes:
        - address: 10.200.0.2
    clusterNetwork:
      bundledIngress: false
      pods:
        cidrBlocks:
        - 192.168.0.0/16
      services:
        cidrBlocks:
        - 10.96.0.0/20
  ...
  

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.

   Nota: Los secretos de TLS deben definirse en el espacio de nombres gke-system.

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. Si no lo hiciste, créalos ahora y sigue los pasos descritos para HTTP.

Crea un Ingress

Crear un Ingress para HTTPS es similar a crear un Ingress para HTTP, pero la especificación de Ingress para HTTPS incluye una sección tls que especifica el host y un Secret. El hosts de la sección tls debe coincidir de forma explícita con el host de la sección rules.

Advertencia: No crees varios Ingress para el mismo host. Cuando usas los componentes de entrada empaquetados, te limitas a un único recurso personalizado de entrada para un host determinado.

Si tu servicio de backend se encuentra en un espacio de nombres independiente, debes crear un servicio de tipo ExternalName en el mismo espacio de nombres que el Ingress para enrutar el tráfico al servicio de backend.

Los pasos generales para crear un Ingress para HTTPS o HTTP son los mismos, excepto por lo que configuras en el archivo de manifiesto:

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

   kubectl --kubeconfig CLUSTER_KUBECONFIG delete ingress my-ingress
   

2. Para controlar el tráfico del Service que creaste antes, crea un nuevo manifiesto de Ingress que tenga una sección tls:

   La configuración de tls habilita HTTPS entre los clientes y el proxy de entrada.

   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
   

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

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

4. Para confirmar que se creó el Ingress y que funciona correctamente, realiza las siguientes pruebas:

   • Prueba la ruta /greet-the-world:

     curl -v --resolve altostrat.com:443: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:CLUSTER_INGRESS_VIP \
         https://altostrat.com/greet-kubernetes --cacert root-ca.crt
     

     Resultado:

     Hello Kubernetes!
     

Crea un Service LoadBalancer

Un Service de tipo LoadBalancer es otra forma de exponer tus cargas de trabajo fuera del clúster. Para obtener instrucciones y un ejemplo sobre cómo crear un servicio de tipo LoadBalancer, consulta Cómo crear un Service de tipo LoadBalancer en Cómo implementar una aplicación.

Realice una limpieza

1. Borra el Ingress:

   kubectl --kubeconfig CLUSTER_KUBECONFIG delete ingress INGRESS_NAME
   

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

2. Borra el Service:

   kubectl --kubeconfig CLUSTER_KUBECONFIG delete service hello-service
   

3. Borra el Deployment:

   kubectl --kubeconfig CLUSTER_KUBECONFIG delete deployment hello-deployment
   

4. Borra tu Service LoadBalancer:

   kubectl --kubeconfig CLUSTER_KUBECONFIG delete service service-does-not-use-nodeports