Búsqueda de sitios web

Cómo ejecutar cargas de trabajo sin servidor con Knative en Kubernetes

El autor seleccionó el programa Write for DOnations.

Introducción

El paradigma sin servidor ayuda a los usuarios a implementar aplicaciones sin tener que preocuparse por la infraestructura subyacente. Con la llegada de Serverless 2.0, muchas plataformas y herramientas ahora le permiten implementar aplicaciones sin servidor en Kubernetes.

Openshift también usa Knative para que los usuarios implementen sus cargas de trabajo sin servidor sobre Kubernetes.

Knative presenta dos componentes principales: Servicio. Eventing administra eventos que desencadenan cargas de trabajo sin servidor. El servicio es un conjunto de componentes para implementar y administrar cargas de trabajo sin servidor. Knative Serving permite a los desarrolladores implementar y administrar aplicaciones sin servidor sobre Kubernetes. Con Knative Serving, los desarrolladores pueden implementar rápida y fácilmente nuevos servicios, escalarlos hacia arriba y hacia abajo y conectarlos a otros servicios y fuentes de eventos. Esta función permite a los desarrolladores crear e implementar aplicaciones nativas de la nube modernas que son flexibles, escalables y fáciles de mantener.

En este tutorial, utilizará Knative Serving para implementar una aplicación Node.js como una carga de trabajo sin servidor en un clúster de DigitalOcean Kubernetes. Utilizará doctl (la CLI de DigitalOcean) y kn (la CLI de Knative) para crear el clúster de Kubernetes e implementar la aplicación.

requisitos previos

Para completar este tutorial, necesitará lo siguiente:

  • Una cuenta de DigitalOcean que utilizará para iniciar un clúster de Kubernetes con al menos 4 GB de RAM y 2 núcleos de CPU. Si no tiene uno, Kubernetes Quickstart.
  • Para seguir este tutorial desde un servidor remoto, puede configurar un servidor Ubuntu 22.04 con un usuario que no sea root y un firewall siguiendo nuestro Inicio rápido de Droplet.
  • El cliente de línea de comandos de DigitalOcean, Cómo usar doctl para obtener más información sobre el uso de doctl.
  • Documentos de instalación de Kubernetes.
  • Docker instalado en su máquina, que puede configurar siguiendo los pasos 1 y 2 de nuestro tutorial sobre cómo instalar y usar Docker.
  • Una aplicación Node.js de muestra configurada siguiendo el tutorial Cómo crear una aplicación Node.js con Docker para crear la aplicación y enviar su imagen de contenedor a Docker Hub.
  • Una cuenta en Docker Hub para almacenar las imágenes de Docker que creará durante este tutorial.

Paso 1: lanzamiento del clúster Kubernetes de DigitalOcean

Dado que Knative es una plataforma basada en Kubernetes, la usará con un clúster de Kubernetes en DigitalOcean. Hay varias formas de lanzar un clúster de Kubernetes en DigitalOcean. Puede utilizar la interfaz de DigitalOcean Cloud, la CLI de DigitalOcean o el proveedor de Terraform.

En este tutorial, utilizará doctl, el cliente de línea de comandos de DigitalOcean, para iniciar el clúster de Kubernetes. Si aún no ha instalado doctl, siga los pasos de la guía de instalación oficial.

Para usar Knative de manera efectiva en este tutorial, necesitará un clúster de Kubernetes con al menos 4 GB de RAM y 2 núcleos de CPU disponibles. Puedes lanzar un clúster llamado knative-tutorial con estas especificaciones ejecutando el comando doctl con las siguientes marcas:

  • --size especifica el tamaño del servidor remoto.
  • --count especifica el número de nodos que se crearán como parte del clúster.

Para crear el clúster de Kubernetes de DigitalOcean, ejecute el siguiente comando:

  1. doctl kubernetes cluster create knative-tutorial --size s-2vcpu-4gb --count 3

En este comando, crea un clúster llamado knative-tutorial con el tamaño establecido en 4 GB de RAM y 2 núcleos de CPU y con un cuenta de 3 nodos.

Nota: también puede usar el indicador --region para especificar en qué región se ubicará el servidor, aunque esa opción no se usa en este tutorial. Si está utilizando un servidor remoto, como un Droplet, es posible que desee tener su clúster en la misma región que el servidor. Si utiliza el Panel de control de DigitalOcean para la Matriz de disponibilidad regional.

Este comando tardará unos minutos en completarse. Una vez que finalice, recibirá un mensaje similar al siguiente:

Output
Notice: Cluster is provisioning, waiting for cluster to be running
...........................................................
Notice: Cluster created, fetching credentials
Notice: Adding cluster credentials to kubeconfig file found in "/home/sammy/.kube/config"
Notice: Setting current-context to do-nyc1-knative-tutorial
ID                                      Name                Region    Version        Auto Upgrade    Status     Node Pools
d2d1f9bc-114b-45e7-b109-104137f9ab62    knative-tutorial    nyc1      1.24.4-do.0    false           running    knative-tutorial-default-pool

El clúster ahora está listo para usar.

Ahora puede verificar si kubectl se ha configurado en su sistema y puede acceder al clúster de Kubernetes de DigitalOcean con el siguiente comando:

  1. kubectl cluster-info

Deberías recibir un resultado similar:

Output
Kubernetes control plane is running at https://69de217e-0284-4e18-a6d7-5606915a4e88.k8s.onlinux-console.net

CoreDNS is running at https://69de217e-0284-4e18-a6d7-5606915a4e88.k8s.onlinux-console.net/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

Dado que el resultado enumera las URL del plano de control y el servicio CoreDNS (resaltado en el bloque de salida), sabe que kubectl está configurado correctamente en su sistema y puede llegar al clúster.

Como parte del proceso de creación del clúster, doctl configura automáticamente el contexto kubectl para usar el nuevo clúster. Puede verificar esto ejecutando el siguiente comando:

  1. kubectl config current-context

Este comando devolverá el nombre del contexto actual.

Debería recibir el siguiente resultado:

Output
do-nyc1-knative-tutorial

El resultado indica que el contexto actual es do-nyc1-knative-tutorial, que es el nombre del clúster que creó con la región en la que se encuentra (nyc1).

También puede verificar que el clúster se esté ejecutando y que los nodos estén listos para aceptar cargas de trabajo con este comando:

  1. kubectl get nodes

El comando kubectl get nodes enumera todos los nodos del clúster junto con su estado y otra información.

Debería recibir el siguiente resultado:

Output
NAME                                       STATUS   ROLES    AGE     VERSION
do-nyc1-knative-tutorial-159783000-0v9k5   Ready    <none>   2m52s   v1.24.4
do-nyc1-knative-tutorial-159783000-1h4qj   Ready    <none>   2m52s   v1.24.4
do-nyc1-knative-tutorial-159783000-1q9qf   Ready    <none>   2m52s   v1.24.4

El resultado indica que el clúster tiene tres nodos listos para aceptar cargas de trabajo.

En este paso, lanzó un clúster de Kubernetes en DigitalOcean. Ahora puede instalar Knative para implementar su carga de trabajo sin servidor en Kubernetes.

Paso 2: Instalación de Knative Serving

En este paso, instalará Knative Serving en su clúster de Kubernetes. Knative Serving es responsable de implementar y administrar sus cargas de trabajo sin servidor.

Para instalar Knative Serving, necesitará los componentes principales y los recursos personalizados de Knative. Ejecute estos comandos para instalar los componentes principales:

  1. kubectl apply -f https://github.com/knative/serving/releases/download/knative-v1.8.0/serving-crds.yaml

  2. kubectl apply -f https://github.com/knative/serving/releases/download/knative-v1.8.0/serving-core.yaml

El comando kubectl apply instala los componentes principales de Knative y los recursos personalizados en su clúster. El indicador -f especifica un archivo que contiene cambios de configuración. En este caso, los cambios de configuración están en los archivos YAML que descargas del repositorio de Knative.

Estos comandos tardarán unos minutos en completarse. Recibirá el siguiente resultado (el resultado a continuación se trunca por brevedad):

Output
customresourcedefinition.apiextensions.k8s.io/certificates.networking.internal.knative.dev created
customresourcedefinition.apiextensions.k8s.io/clusteringresses.networking.internal.knative.dev created
customresourcedefinition.apiextensions.k8s.io/configurations.serving.knative.dev created
customresourcedefinition.apiextensions.k8s.io/images.caching.internal.knative.dev created
customresourcedefinition.apiextensions.k8s.io/ingresses.networking.internal.knative.dev created
...

Este resultado indica que los componentes principales y los recursos personalizados de Knative están en su clúster. Todos los componentes están en el espacio de nombres knative-serving.

Una vez que hayan terminado de descargarse, puedes verificar que Knative Serving está instalado:

  1. kubectl get pods --namespace knative-serving

El comando kubectl get pods recuperará una lista de todos los pods lanzados en el clúster en el espacio de nombres knative-serving. Este comando identifica los pods en su clúster, su estado actual, la cantidad de contenedores en el pod y los nombres de los contenedores en un espacio de nombres particular.

Deberías recibir un resultado similar:

Output
NAME                                      READY   STATUS    RESTARTS   AGE
activator-5f6b4bf5c8-kfxrv                1/1     Running   0          4m37s
autoscaler-bc7d6c9c9-v5jqt                1/1     Running   0          4m34s
controller-687d88ff56-9g4gz               1/1     Running   0          4m32s
domain-mapping-69cc86d8d5-kr57g           1/1     Running   0          4m29s
domainmapping-webhook-65dfdd9b96-nzs9c    1/1     Running   0          4m27s
net-kourier-controller-55c99987b4-hkfpl   1/1     Running   0          3m49s
webhook-587cdd8dd7-qbb9b                  1/1     Running   0          4m22s

El resultado muestra todos los pods que se ejecutan en el espacio de nombres knative-serving. Los pods son responsables de los diferentes componentes de Knative Serving.

Knative requiere una capa de red para enrutar el tráfico entrante a sus servicios. La capa de red en Knative permite la implementación y comunicación de microservicios en un entorno distribuido. Knative Serving es compatible con Kourier como capa de red.

En este tutorial, utilizará Kourier como capa de red porque se integra a la perfección con Knative. Kourier usa las mismas API y estándares que el resto del ecosistema de Knative, lo que lo convierte en una buena opción para los desarrolladores y las organizaciones que ya usan Knative y desean beneficiarse de sus poderosas capacidades de red.

Instale Kourier con este comando:

  1. kubectl apply -f https://github.com/knative/net-kourier/releases/download/knative-v1.8.0/kourier.yaml

Debería recibir el siguiente resultado:

Output
namespace/kourier-system configured
configmap/kourier-bootstrap configured
configmap/config-kourier configured
serviceaccount/net-kourier configured
clusterrole.rbac.authorization.k8s.io/net-kourier configured
clusterrolebinding.rbac.authorization.k8s.io/net-kourier configured
deployment.apps/net-kourier-controller configured
service/net-kourier-controller configured
deployment.apps/3scale-kourier-gateway configured
service/kourier configured
service/kourier-internal configured

El resultado enumera todos los recursos, como Namespaces y ConfigMaps, creados como parte del proceso de instalación de Kourier en el clúster de Kubernetes.

Para configurar Knative para usar Kourier como la capa de red, editará el mapa de configuración config-network.

Para ello, debe usar el comando kubectl patch para actualizar los campos de un objeto en un clúster de Kubernetes. Tendrás que incluir también algunas banderas con este comando:

  • --namespace especifica dónde puede encontrar el objeto que desea parchear.
  • --type especifica qué parche realizar al aplicar configuraciones con el comando patch. Los tipos disponibles son json, merge y strategic.
  • --patch especifica los datos del parche directamente en la línea de comando en lugar de en un archivo.

Ejecute este comando con las banderas asociadas:

  1. kubectl patch configmap/config-network \

  2.   --namespace knative-serving \

  3.   --type merge \

  4.   --patch '{"data":{"ingress-class":"kourier.ingress.networking.knative.dev"}}'

El comando kubectl patch parchea configmap/config-network con el namespace establecido en knative-serving y el type establecido en merge.

El tipo de parche merge permite actualizaciones más específicas, mientras que los tipos de parche json o strategic permiten actualizaciones más completas. El tipo de parche merge especifica campos individuales para actualizar sin incluir toda la configuración de recursos en el comando de parche, como es el caso de los otros tipos. Los datos que se parchean se identifican con el indicador patch.

Debería recibir el siguiente resultado:

Output
configmap/config-network patched

El resultado de este comando garantiza que Kourier esté configurado correctamente en el clúster.

Finalmente, obtenga la dirección IP externa del balanceador de carga de Kourier con el siguiente comando:

  1. kubectl get svc kourier --namespace kourier-system

El comando kubectl get svc recupera información sobre los servicios que se ejecutan en un clúster de Kubernetes en el espacio de nombres mencionado (en este caso, kourier-system). Este comando enumerará todos los servicios en el clúster con sus direcciones IP y números de puerto asociados.

Debería recibir el siguiente resultado:

Output
NAME      TYPE           CLUSTER-IP       EXTERNAL-IP      PORT(S)                      AGE
kourier   LoadBalancer   10.245.186.153   138.197.231.61   80:31245/TCP,443:30762/TCP   2m33s

El resultado del comando incluye el nombre del servicio, el tipo de servicio (como ClusterIP, NodePort, etc.), la dirección IP del clúster y el número de puerto, y la dirección IP externa y el número de puerto. Los números enumerados aquí son ejemplos, por lo que su salida mostrará números diferentes.

El balanceador de carga puede tardar unos minutos en aprovisionarse. Es posible que vea un valor vacío o <pending> para el campo EXTERNAL-IP. Si ese es el caso, espere unos minutos y vuelva a ejecutar el comando.

Nota: Deberá aprovisionar el equilibrador de carga antes de continuar con este tutorial. Una vez que se completa el campo EXTERNAL-IP para el LoadBalancer, puede continuar. De lo contrario, puede experimentar problemas al configurar el servicio DNS.

También puede configurar DNS para que su nombre de dominio apunte a la dirección IP externa del balanceador de carga. Knative proporciona un trabajo de Kubernetes llamado default-domain que configurará automáticamente Knative Serving para usar sslip.io como el sufijo DNS predeterminado.

sslip.io es un servicio de DNS (Domain Name System) dinámico que permite a los usuarios acceder a sus dispositivos utilizando un nombre de dominio personalizado en lugar de la dirección IP. El uso de sslip.io mejora el acceso de los usuarios a sus dispositivos de forma remota sin necesidad de recordar direcciones IP complejas.

Para configurar el sufijo DNS predeterminado, deberá ejecutar el siguiente comando:

  1. kubectl apply -f https://github.com/knative/serving/releases/download/knative-v1.8.0/serving-default-domain.yaml

Recibirá el siguiente resultado:

Output
job.batch/default-domain configured
service/default-domain-service configured

Los recursos necesarios para ejecutar el servicio Magic DNS se han configurado correctamente.

Nota: también puede agregar un dominio si lo prefiere, aunque eso está más allá del alcance de este artículo. Debe configurar un proveedor de DNS (como Cloud DNS o Route53) y crear un registro A para la puerta de enlace de ingreso de Knative que está asignada a la dirección IP de su clúster de Knative. Luego, actualizaría la configuración de la puerta de enlace de ingreso de Knative para usar la zona DNS y el registro A que creó. Puede probar la configuración de DNS accediendo al dominio de servicio de Knative y asegurándose de que se resuelva en la puerta de enlace de entrada.

Ahora ha instalado correctamente Knative Serving en su clúster de Kubernetes. Ahora puede implementar la carga de trabajo sin servidor con Knative Serving en su clúster de Kubernetes.

Paso 3: Implementación de una carga de trabajo sin servidor

En este paso, implementará una carga de trabajo sin servidor sobre Knative, que actualmente se ejecuta en su clúster de Kubernetes. Utilizará la aplicación Node.js que creó como parte de los requisitos previos.

Antes de continuar, creará un nuevo namespace para implementar su carga de trabajo sin servidor. Puede hacer esto ejecutando el siguiente comando:

  1. kubectl create namespace serverless-workload

Este comando creará un nuevo espacio de nombres llamado serverless-workload.

Debería recibir el siguiente resultado:

Output
namespace/serverless-workload configured

El resultado garantiza que el espacio de nombres se haya creado correctamente.

Knative Serving usa un recurso personalizado llamado Service para implementar y administrar sus cargas de trabajo sin servidor. El recurso Service está definido por la API de servicio de Knative.

Una vez que cree o modifique el recurso Service, Knative Serving creará automáticamente una nueva Revisión. Una Revisión es una instantánea de un momento dado de su carga de trabajo.

Cada vez que se crea una nueva Revisión, el tráfico se enrutará a la nueva Revisión mediante una Ruta. Knative Serving crea automáticamente una Ruta para cada Servicio. Puede acceder a su carga de trabajo utilizando el nombre de dominio de la Ruta.

Para implementar una carga de trabajo sin servidor en Knative, debe crear un recurso Service. Puedes lograr esto de dos maneras diferentes:

  • Utilizando kn, la herramienta CLI oficial de Knative.
  • Utilizar la herramienta de línea de comandos kubectl para aplicar archivos YAML a su clúster de Kubernetes.

En las subsecciones siguientes, utilizará cada uno de estos métodos.

Opción 1: usar la CLI de Knative

La CLI de Knative, kn, es una interfaz de línea de comandos que le permite interactuar con Knative.

Primero, instale kn descargando la última versión del binario Knative CLI:

  1. wget https://github.com/knative/client/releases/download/knative-v1.8.1/kn-linux-amd64

El comando wget recuperará la herramienta.

Luego, mueva el binario a una carpeta llamada kn:

  1. mv kn-linux-amd64 kn

A continuación, hazlo ejecutable con el siguiente comando:

  1. chmod +x kn

Finalmente, mueva el archivo binario ejecutable a un directorio en su PATH:

  1. cp kn /usr/local/bin/

Verifique que kn esté instalado:

  1. kn version

Deberías recibir un resultado similar:

Output
Version:      v1.8.1
Build Date:   2022-10-20 16:09:37
Git Revision: 1db36698
Supported APIs:
* Serving
  - serving.knative.dev/v1 (knative-serving v1.8.0)
* Eventing
  - sources.knative.dev/v1 (knative-eventing v1.8.0)
  - eventing.knative.dev/v1 (knative-eventing v1.8.0)

El resultado de este comando indica que se instaló kn.

Para implementar la aplicación Node.js usando kn, usará el comando kn service create. Incluirá algunas banderas con este comando:

  • --image especifica la imagen del contenedor que desea implementar.
  • --port especifica el puerto en el que escucha su aplicación.
  • --name especifica el nombre del Servicio que desea crear.
  • --namespace especifica el espacio de nombres en el que desea implementar la carga de trabajo.

Para implementar su aplicación Node.js, ejecute el siguiente comando y actualice la parte resaltada con su nombre de usuario de DockerHub:

  1. kn service create node-service \

  2.   --image your_dockerhub_username/nodejs-image-demo \

  3.   --port 8080 \

  4.   --namespace serverless-workload

El comando kn service crea el servicio Knative denominado node-service con el port establecido en 8080 y el namespace establecida en serverless-workload. El indicador image indica la ubicación del contenedor de la aplicación cargado en Dockerhub.

Debería recibir el siguiente resultado:

Output
Creating service 'node-service' in namespace 'serverless-workload':

  0.236s Configuration "node-service" is waiting for a Revision to become ready.
  2.230s ...
  2.311s Ingress has not yet been reconciled.
  2.456s Waiting for load balancer to be ready
  2.575s Ready to serve.

Service 'node-service' created to latest revision 'node-service-00001' is available at URL:
http://node-service.serverless-workload.138.197.231.61.sslip.io

Esta salida proporciona el estado de la creación del Service de Knative. Una vez que se crea el Servicio, encontrará la URL de la Ruta vinculada al Servicio.

Ejecute el siguiente comando para verificar que se creó el recurso Service:

  1. kn service list --namespace serverless-workload

El comando kn service list enumera todos los servicios implementados actualmente con Knative Serving en un espacio de nombres particular en el clúster de Kubernetes. Este comando le permite acceder a detalles sobre cada Servicio, incluido su nombre, estado y URL.

Deberías recibir un resultado similar:

Output
NAME           URL                                                               LATEST               AGE   CONDITIONS   READY   REASON
node-service   http://node-service.serverless-workload.138.197.231.61.sslip.io   node-service-00001   88s   3 OK / 3     True

A partir de este resultado, puede verificar que el comando kn service que ejecutó anteriormente ha creado un nuevo Service de Knative. También encontrará la URL para la Ruta y la Age y Status del Servicio.

En esta sección, instaló la CLI de Knative y la usó para implementar una carga de trabajo sin servidor para su aplicación Node.js.

Opción 2: crear un recurso de servicio mediante archivos YAML

También puede implementar un recurso Service creando un archivo YAML que defina el recurso. Este método es útil para garantizar el control de versiones de sus cargas de trabajo.

Primero, creará un subdirectorio en el directorio que contiene su Dockerfile. Este tutorial usa el nombre knative para el subdirectorio. Crea la carpeta:

  1. mkdir knative

A continuación, creará un archivo YAML llamado service.yaml en el directorio knative:

  1. nano knative/service.yaml

En el archivo service.yaml recién creado, agregue las siguientes líneas para definir un Service que implementará su aplicación Node.js:

apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: node-yaml-service
  namespace: serverless-workload
spec:
  template:
    metadata:
      name: node-yaml-service-v1
    spec:
      containers:
        - image: docker.io/your_dockerhub_username/nodejs-image-demo
          ports:
            - containerPort: 8080

El archivo YAML de Knative Service especifica la siguiente información:

  • name en la primera sección metadata especifica el name del recurso Service.
  • namespace especifica el namespace en el que desea implementar la carga de trabajo.
  • name en la primera sección spec especifica el name de la Revisión.
  • imagen en la segunda sección spec especifica la imagen del contenedor que desea implementar.
  • containerPort especifica el puerto en el que escucha su aplicación.

Asegúrese de actualizar el texto resaltado con la información que ha seleccionado para su aplicación y sistema, así como su nombre de usuario de DockerHub.

Guarde y cierre el archivo.

Ahora puede implementar el recurso Service ejecutando el siguiente comando:

  1. kubectl apply -f knative/service.yaml

Debería recibir el siguiente resultado:

Output
service.serving.knative.dev/node-yaml-service created

El resultado indica que el recurso Service se ha creado correctamente.

Ejecute el siguiente comando para verificar que se haya creado el recurso Service:

  1. kn service list --namespace serverless-workload

El comando kn service list enumera todos los servicios implementados actualmente con Knative Serving en un espacio de nombres en particular. Este comando le permite acceder a detalles sobre cada Servicio.

Debería recibir el siguiente resultado:

Output
NAME                URL                                                                     LATEST                 AGE   CONDITIONS   READY   REASON
node-service        http://node-service.serverless-workload.174.138.127.211.sslip.io        node-service-00001     9d    3 OK / 3     True    
node-yaml-service   http://node-yaml-service.serverless-workload.174.138.127.211.sslip.io   node-yaml-service-v1   9d    3 OK / 3     True

Puede verificar que se haya creado un nuevo Service de Knative basado en el archivo YAML de Knative Service que ejecutó anteriormente. Creó el node-yaml-service en esta sección. También puede encontrar la URL de la Ruta de Knative.

Usó un archivo YAML en esta sección para crear una carga de trabajo sin servidor para su aplicación Node.js.

En este paso, creó el recurso Service de Knative utilizando la herramienta CLI kn y un archivo YAML. A continuación, accederá a la carga de trabajo de la aplicación que implementó con Knative.

Paso 4: Acceder a la carga de trabajo de la aplicación

Ahora que ha implementado la carga de trabajo sin servidor, puede acceder a ella con la URL de la Ruta de Knative creada como parte de la carga de trabajo sin servidor. La ruta Knative define cómo se debe enrutar el tráfico HTTP entrante a un servicio o aplicación específicos.

Para obtener la lista de todas las rutas de Knative, ejecute el siguiente comando:

  1. kn route list --namespace serverless-workload

El comando kn route list enumera todas las rutas de Knative en un espacio de nombres particular en el clúster de Kubernetes.

Deberías recibir un resultado similar:

Output
NAME                URL                                                                    READY
node-service        http://node-service.serverless-workload.138.197.231.61.sslip.io        True
node-yaml-service   http://node-yaml-service.serverless-workload.138.197.231.61.sslip.io   True

Utilizará las URL generadas para Knative Routes para confirmar que todo funciona como se esperaba.

Abra cualquiera de las URL en su navegador. Cuando acceda al sitio en su navegador, se cargará la página de destino de su aplicación Node:

Ha implementado correctamente una carga de trabajo sin servidor con Knative en su clúster de Kubernetes.

Conclusión

En este tutorial, implementó una carga de trabajo sin servidor con Knative. Creó un recurso Service de Knative utilizando la herramienta CLI kn y a través de archivos YAML. Este recurso implementó una aplicación Node.js en su clúster de Kubernetes, al que accedió mediante la URL Route.

Para obtener más información sobre las funciones que ofrece Knative, como la documentación de Knative.

Para continuar construyendo con DigitalOcean Kubernetes (DOKS), consulte nuestras guías de soporte de Kubernetes.

Artículos relacionados: