Se usó la API de Cloud Translation para traducir esta página.

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 Deployment:

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"

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.

Copia el manifiesto en un archivo llamado hello-deployment.yaml.
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:

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

Copia el manifiesto en un archivo llamado hello-service.yaml.
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.
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 Service, 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 (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).
- 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:

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 o Cloud Service Mesh.

Crea un Ingress

Sigue estos pasos para crear un objeto Ingress:

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

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

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: ...
```
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 las 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:

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

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 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
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 secreto. El hosts de la sección tls debe coincidir explícitamente con el host de la sección rules.

Si tu servicio de backend está en un espacio de nombres separado, 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 configures en el archivo de manifiesto:

Si antes creaste un Ingress en la parte HTTP de este documento, bórralo antes de continuar.
```
kubectl --kubeconfig CLUSTER_KUBECONFIG delete ingress my-ingress
```

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

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 objeto Ingress se creó y 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 para crear un servicio de tipo LoadBalancer, consulta Crea un Service de tipo LoadBalancer en Implementa una aplicación.

Realiza una limpieza

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.

Borra el Service:

kubectl --kubeconfig CLUSTER_KUBECONFIG delete service hello-service

Borra el Deployment:

kubectl --kubeconfig CLUSTER_KUBECONFIG delete deployment hello-deployment

Borra el Service LoadBalancer:

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

Crear un Service y un Ingress Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Crear una implementación

Expón tu Deployment con un Service

Componentes de Ingress

Crea un Ingress

La ruta /greet-the-world

La ruta /greet-kubernetes

Prueba el Ingress:

Inhabilita el Ingress agrupado

Configura HTTPS para Ingress

Crea una implementación y un servicio

Crea un Ingress

Crea un Service LoadBalancer

Realiza una limpieza

Crear un Service y un Ingress

La ruta `/greet-the-world`

La ruta `/greet-kubernetes`