Esta página se ha traducido con Cloud Translation API.

Crear objetos Ingress y Service

En este documento se muestra cómo crear un objeto Ingress de Kubernetes en un clúster de usuario, híbrido o independiente de Google Distributed Cloud. Un Ingress se asocia a uno o varios Services, cada uno de los cuales se asocia a un conjunto de Pods.

Crear un despliegue

Sigue estos pasos para crear una implementación:

Crea un archivo de 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"

En este ejercicio, estos son los puntos importantes que debes tener en cuenta sobre el manifiesto de la implementación:

Cada pod que pertenece a la implementación tiene la etiqueta greeting: hello.
Cada pod tiene dos contenedores.
Los campos env especifican 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 consultando el código fuente.

Copia el manifiesto en un archivo llamado hello-deployment.yaml.
Crea el despliegue:
```
kubectl apply --kubeconfig CLUSTER_KUBECONFIG -f hello-deployment.yaml
```
Sustituye CLUSTER_KUBECONFIG por el nombre del archivo kubeconfig de tu clúster.

Exponer un Deployment con un Service

Para que los clientes puedan enviar solicitudes a los pods de tu implementación de forma estable, crea un servicio:

Crea un manifiesto de servicio que exponga tu Deployment a los clientes de tu 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.
Crea el servicio:
```
kubectl apply --kubeconfig CLUSTER_KUBECONFIG -f hello-service.yaml
```
Sustituye CLUSTER_KUBECONFIG por el nombre del archivo kubeconfig de tu clúster.
Ver el servicio:
```
kubectl --kubeconfig CLUSTER_KUBECONFIG get service hello-service --output yaml
```
El resultado muestra el valor de clusterIP que se ha asignado al servicio. 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 una matriz de objetos ServicePort: uno llamado world-port y otro llamado kubernetes-port. Para obtener más información sobre los campos de Service, consulta ServiceSpec en la documentación de Kubernetes.

Estas son las formas en las que un cliente puede llamar al Servicio:
- Uso de world-port: un cliente que se ejecuta en uno de los nodos del clúster envía una solicitud a clusterIP en port (por ejemplo, 10.96.14.249:60000). El controlador de entrada reenvía la solicitud a un pod miembro en targetPort (por ejemplo, POD_IP_ADDRESS:50000, donde POD_IP_ADDRESS es la dirección IP de un pod miembro).
- Uso de 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 el ingreso:

de la documentación de Cloud Service Mesh.

La istio-ingressimplementación. 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 istio-ingress. Este servicio expone el istio-ingress Deployment.
La istiodimplementación. Este es el controlador de entrada. El controlador de entrada monitoriza la creación de objetos Ingress y configura el proxy de entrada en consecuencia.

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

Crear un Ingress

Sigue estos pasos para crear un Ingress:

Crea un archivo de 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

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

Crea el Ingress:

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

Cuando creas un clúster de usuarios, especificas un valor para loadbalancer.ingressVIP en el archivo de configuración del clúster. Esta dirección IP está configurada en el balanceador de carga del clúster. Cuando creas un Ingress, se le asigna la misma IP virtual como dirección IP externa.

Cuando un cliente envía una solicitud a la dirección IP virtual de entrada de tu clúster de usuario, la solicitud se enruta a tu balanceador de carga. El balanceador de carga usa el servicio istio-ingress para reenviar la solicitud al proxy de entrada, que se ejecuta en tu clúster de usuario. El proxy de entrada reenvía la solicitud a diferentes back-ends en función de la ruta de la URL de la solicitud.

Ruta `/greet-the-world`

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

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

El servicio de entrada reenvía la solicitud a clusterIP:50000. A continuación, la solicitud se envía a uno de los pods miembros del servicio hello-service. El contenedor de ese pod, que escucha en el puerto 50000, muestra un mensaje Hello World!.

Ruta `/greet-kubernetes`

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

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

El servicio de entrada reenvía la solicitud a clusterIP: 8080. A continuación, la solicitud se envía a uno de los pods miembros del servicio hello-service. El contenedor de ese pod, que escucha en el puerto 8080, muestra un mensaje Hello Kubernetes!.

Probar el objeto Ingress

Prueba el Ingress con la ruta /greet-the-world:
```
curl CLUSTER_INGRESS_VIP/greet-the-world
```
Sustituye 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 CLUSTER_INGRESS_VIP/greet-kubernetes
```
El resultado muestra un mensaje Hello, Kubernetes!:
```
Hello Kubernetes!
```

Inhabilitar Ingress incluido

La función de entrada incluida en Google Distributed Cloud solo admite funciones de entrada. Puedes integrar Istio o Cloud Service Mesh. Estos productos ofrecen las ventajas adicionales de una malla de servicios totalmente funcional, como la seguridad de la capa de transporte mutua (mTLS), la capacidad de gestionar la autenticación entre servicios y la observabilidad de las cargas de trabajo. Si integras Istio o Cloud Service Mesh, te recomendamos que inhabilites la función Ingress incluida.

Puede habilitar o inhabilitar Ingress agrupado con el campo spec.clusterNetwork.bundledIngress en el archivo de configuración del clúster. Este campo solo está disponible en clústeres de la versión 1.13.0 y posteriores. El campo bundledIngress tiene el valor predeterminado true y no está presente en el archivo de configuración del clúster generado. Este campo es mutable y se puede cambiar al crear o actualizar un clúster con la versión 1.13.0 o posterior.

Para inhabilitar la función Ingress incluida, añade el campo bundledIngress a la sección clusterNetwork del archivo de configuración del clúster y asigna el valor "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
...

Configurar HTTPS para Ingress

Si quieres aceptar solicitudes HTTPS de tus clientes, el proxy de entrada debe tener un certificado para poder demostrar su identidad a tus clientes. Este proxy también debe tener una clave privada para completar el handshake de HTTPS.

En el siguiente ejemplo se usan estas entidades:

Proxy de Ingress: participa en la negociación de enlace HTTPS y, a continuación, reenvía paquetes a los pods miembros del servicio hello-service.
Dominio del servicio hello-service: altostrat.com en Ejemplo de organización

Sigue estos pasos:

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 Root CA Example Org.

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

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"

Crea un certificado de servicio 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
```
Ahora has creado los siguientes certificados y claves:
- root-ca.crt: certificado de la AC raíz
- root-ca.key: clave privada de la CA raíz
- server.crt: Certificado de servicio del proxy de entrada
- server.key: clave privada del proxy de entrada.
Crea un secreto de Kubernetes que contenga el certificado y la clave de servicio.
```
kubectl create secret tls example-server-creds --key=server.key --cert=server.crt \
    --namespace gke-system
```
El secreto resultante se llama example-server-creds.

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

Crear un despliegue y un servicio

Si has creado una implementación y un servicio en la parte HTTP de esta guía, déjalos como están. Si no lo has hecho, créalas ahora siguiendo los pasos descritos para HTTP.

Crear 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. Los hosts de la sección tls deben coincidir explícitamente con los host de la sección rules.

Si tu servicio de backend está 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 se configura en el archivo de manifiesto:

Si has creado un Ingress en la sección HTTP de este documento, elimínalo antes de continuar.
```
kubectl --kubeconfig CLUSTER_KUBECONFIG delete ingress my-ingress
```

Para gestionar el tráfico del servicio que creó anteriormente, cree un manifiesto de entrada 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

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
```

Para confirmar que el Ingress se ha creado y funciona correctamente, haz lo siguiente:

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!

Crear un servicio LoadBalancer

Un servicio 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 el artículo Crear un servicio de tipo LoadBalancer en Implementar una aplicación.

Eliminar los recursos utilizados

Eliminar tu Ingress:
```
kubectl --kubeconfig CLUSTER_KUBECONFIG delete ingress INGRESS_NAME
```
Sustituye INGRESS_NAME por el nombre del Ingress, como my-ingress o my-ingress-2.

Eliminar tu Servicio:

kubectl --kubeconfig CLUSTER_KUBECONFIG delete service hello-service

Eliminar tu implementación:

kubectl --kubeconfig CLUSTER_KUBECONFIG delete deployment hello-deployment

Elimina el servicio LoadBalancer:

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

Crear objetos Ingress y Service Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Crear un despliegue

Exponer un Deployment con un Service

Componentes de Ingress

Crear un Ingress

Ruta /greet-the-world

Ruta /greet-kubernetes

Probar el objeto Ingress

Inhabilitar Ingress incluido

Configurar HTTPS para Ingress

Crear un despliegue y un servicio

Crear un Ingress

Crear un servicio LoadBalancer

Eliminar los recursos utilizados

Crear objetos Ingress y Service

Ruta `/greet-the-world`

Ruta `/greet-kubernetes`