For AI agents: the complete documentation index is available at https://docs.ovhcloud.com/fr/llms.txt, the full documentation bundle is available at https://docs.ovhcloud.com/fr/llms-full.txt, and this page is available as Markdown at https://docs.ovhcloud.com/fr/guides/public-cloud/containers-orchestration/managed-kubernetes/install-knative.md.

Exécuter des conteneurs Serverless sur OVHcloud Managed Kubernetes avec Knative

Voir en Markdown

Découvrez comment installer Knative sur OVHcloud Managed Kubernetes et déployer vos premiers conteneurs serverless

Objectif

Knative est une plateforme permettant de déployer et de gérer des applications Serverless sur Kubernetes.

Knative

Knative fournit un ensemble de composants middleware construits au-dessus de Kubernetes, qui masquent les détails complexes et permettent aux développeurs de se concentrer sur l'essentiel. Construit en codifiant les bonnes pratiques partagées par des implémentations réelles ayant fait leurs preuves, Knative résout les aspects « ennuyeux mais difficiles » du déploiement et de la gestion des services cloud native, afin que vous n'ayez pas à le faire vous-même.

Concrètement, vous allez déployer des composants Knative, et Knative créera lui-même les composants Kubernetes nécessaires. Vous n'avez pas à vous soucier des composants Kubernetes.

Knative prend en charge plusieurs couches de routage HTTP, notamment Istio, Gloo, Contour, Kourier et Ambassador.

Knative comporte deux composants :

  • Serving
  • Eventing

Composants Knative

Il permet notamment :

  • le déploiement rapide de conteneurs Serverless ;
  • le scale to zero (pas d'appel = pas de pod = pas de consommation de mémoire/CPU) ;
  • le scale from zero (pic de trafic démarre x pods) ;
  • la gestion de la configuration et des révisions ;
  • la répartition du trafic entre les révisions, blue/green... ;
  • un système d'eventing.

Pour en savoir plus sur les fonctionnalités de Knative 1.0.

Knative a atteint la version 1.0. Pour célébrer cette étape, ce tutoriel vous guide dans l'installation de Knative sur un cluster OVHcloud Managed Kubernetes Service nouvellement créé, puis dans le déploiement d'une application d'exemple utilisant le composant Knative Serving. Vous pouvez utiliser la fonction Réinitialiser le cluster dans la section Public Cloud de l' pour réinitialiser votre cluster avant de suivre ce tutoriel.

Prérequis

Ce tutoriel suppose que vous disposez déjà d'un cluster OVHcloud Managed Kubernetes fonctionnel, ainsi que de connaissances de base sur son fonctionnement. Pour en savoir plus sur ces sujets, consultez la documentation Déployer une application Hello World.

En pratique

Installer la CLI Knative « kn »

La CLI Knative (kn) offre une interface rapide et simple pour créer des ressources Knative, comme des Knative Services et des sources d'événements, sans avoir à créer ou modifier directement des fichiers YAML.

kn simplifie également la réalisation de procédures autrement complexes, comme l'autoscaling et la répartition du trafic.

Pour installer la CLI, suivez les instructions correspondant à votre système d'exploitation.

Vérifiez ensuite que la CLI est correctement installée sur votre machine :

kn version

Voici un exemple de résultat :

$ kn version
Version:      v1.17.0
Build Date:   2025-01-22 16:25:15
Git Revision: f7347245
Supported APIs:
* Serving
  - serving.knative.dev/v1 (knative-serving v1.17.0)
* Eventing
  - sources.knative.dev/v1 (knative-eventing v1.17.0)
  - eventing.knative.dev/v1 (knative-eventing v1.17.0)

Installer Knative

Installer le composant Knative Serving

La première chose à faire est d'installer le composant Knative Serving :

  • Installez les ressources personnalisées requises en exécutant la commande :
kubectl apply -f https://github.com/knative/serving/releases/latest/download/serving-crds.yaml

Voici un exemple de résultat :

$ kubectl apply -f https://github.com/knative/serving/releases/latest/download/serving-crds.yaml
customresourcedefinition.apiextensions.k8s.io/certificates.networking.internal.knative.dev created
customresourcedefinition.apiextensions.k8s.io/configurations.serving.knative.dev created
customresourcedefinition.apiextensions.k8s.io/clusterdomainclaims.networking.internal.knative.dev created
customresourcedefinition.apiextensions.k8s.io/domainmappings.serving.knative.dev created
customresourcedefinition.apiextensions.k8s.io/ingresses.networking.internal.knative.dev created
customresourcedefinition.apiextensions.k8s.io/metrics.autoscaling.internal.knative.dev created
customresourcedefinition.apiextensions.k8s.io/podautoscalers.autoscaling.internal.knative.dev created
customresourcedefinition.apiextensions.k8s.io/revisions.serving.knative.dev created
customresourcedefinition.apiextensions.k8s.io/routes.serving.knative.dev created
customresourcedefinition.apiextensions.k8s.io/serverlessservices.networking.internal.knative.dev created
customresourcedefinition.apiextensions.k8s.io/services.serving.knative.dev created
customresourcedefinition.apiextensions.k8s.io/images.caching.internal.knative.dev created
  • Installez les composants principaux de Knative Serving en exécutant la commande :
kubectl apply -f https://github.com/knative/serving/releases/latest/download/serving-core.yaml

Voici un exemple de résultat :

$ kubectl apply -f https://github.com/knative/serving/releases/latest/download/serving-core.yaml
namespace/knative-serving created
role.rbac.authorization.k8s.io/knative-serving-activator created
clusterrole.rbac.authorization.k8s.io/knative-serving-activator-cluster created
clusterrole.rbac.authorization.k8s.io/knative-serving-aggregated-addressable-resolver created
clusterrole.rbac.authorization.k8s.io/knative-serving-addressable-resolver created
clusterrole.rbac.authorization.k8s.io/knative-serving-namespaced-admin created
clusterrole.rbac.authorization.k8s.io/knative-serving-namespaced-edit created
clusterrole.rbac.authorization.k8s.io/knative-serving-namespaced-view created
clusterrole.rbac.authorization.k8s.io/knative-serving-core created
clusterrole.rbac.authorization.k8s.io/knative-serving-podspecable-binding created
serviceaccount/controller created
clusterrole.rbac.authorization.k8s.io/knative-serving-admin created
clusterrolebinding.rbac.authorization.k8s.io/knative-serving-controller-admin created
clusterrolebinding.rbac.authorization.k8s.io/knative-serving-controller-addressable-resolver created
serviceaccount/activator created
rolebinding.rbac.authorization.k8s.io/knative-serving-activator created
clusterrolebinding.rbac.authorization.k8s.io/knative-serving-activator-cluster created
customresourcedefinition.apiextensions.k8s.io/images.caching.internal.knative.dev unchanged
certificate.networking.internal.knative.dev/routing-serving-certs created
customresourcedefinition.apiextensions.k8s.io/certificates.networking.internal.knative.dev unchanged
customresourcedefinition.apiextensions.k8s.io/configurations.serving.knative.dev unchanged
customresourcedefinition.apiextensions.k8s.io/clusterdomainclaims.networking.internal.knative.dev unchanged
customresourcedefinition.apiextensions.k8s.io/domainmappings.serving.knative.dev unchanged
customresourcedefinition.apiextensions.k8s.io/ingresses.networking.internal.knative.dev unchanged
customresourcedefinition.apiextensions.k8s.io/metrics.autoscaling.internal.knative.dev unchanged
customresourcedefinition.apiextensions.k8s.io/podautoscalers.autoscaling.internal.knative.dev unchanged
customresourcedefinition.apiextensions.k8s.io/revisions.serving.knative.dev unchanged
customresourcedefinition.apiextensions.k8s.io/routes.serving.knative.dev unchanged
customresourcedefinition.apiextensions.k8s.io/serverlessservices.networking.internal.knative.dev unchanged
customresourcedefinition.apiextensions.k8s.io/services.serving.knative.dev unchanged
image.caching.internal.knative.dev/queue-proxy created
configmap/config-autoscaler created
configmap/config-certmanager created
configmap/config-defaults created
configmap/config-deployment created
configmap/config-domain created
configmap/config-features created
configmap/config-gc created
configmap/config-leader-election created
configmap/config-logging created
configmap/config-network created
configmap/config-observability created
configmap/config-tracing created
horizontalpodautoscaler.autoscaling/activator created
poddisruptionbudget.policy/activator-pdb created
deployment.apps/activator created
service/activator-service created
deployment.apps/autoscaler created
service/autoscaler created
deployment.apps/controller created
service/controller created
horizontalpodautoscaler.autoscaling/webhook created
poddisruptionbudget.policy/webhook-pdb created
deployment.apps/webhook created
service/webhook created
validatingwebhookconfiguration.admissionregistration.k8s.io/config.webhook.serving.knative.dev created
mutatingwebhookconfiguration.admissionregistration.k8s.io/webhook.serving.knative.dev created
validatingwebhookconfiguration.admissionregistration.k8s.io/validation.webhook.serving.knative.dev created
secret/webhook-certs created

Installer une couche réseau (Ingress Gateway)

Comme couche réseau, vous pouvez installer celle de votre choix : Istio, Contour, Gloo ou Ambassador. Dans ce tutoriel, nous allons installer Kourier : un Ingress léger pour Knative Serving.

Installez le contrôleur Knative Kourier en exécutant la commande :

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

namespace/kourier-system created
configmap/kourier-bootstrap created
configmap/config-kourier created
serviceaccount/net-kourier created
clusterrole.rbac.authorization.k8s.io/net-kourier created
clusterrolebinding.rbac.authorization.k8s.io/net-kourier created
deployment.apps/net-kourier-controller created
service/net-kourier-controller created
deployment.apps/3scale-kourier-gateway created
service/kourier created
service/kourier-internal created
horizontalpodautoscaler.autoscaling/3scale-kourier-gateway created
poddisruptionbudget.policy/3scale-kourier-gateway-pdb created

Configurez Knative Serving pour utiliser Kourier par défaut en exécutant la commande :

kubectl patch configmap/config-network \
  --namespace knative-serving \
  --type merge \
  --patch '{"data":{"ingress.class":"kourier.ingress.networking.knative.dev"}}'

Comme vous pouvez le constater, un nouveau namespace kourier-system est créé avec un déploiement :

$ kubectl get deploy -n kourier-system
NAME                     READY   UP-TO-DATE   AVAILABLE   AGE
3scale-kourier-gateway   1/1     1            1           104m

Récupérez l'adresse IP externe ou le CNAME en exécutant la commande :

kubectl get service kourier -n kourier-system

Voici un exemple de résultat :

$ kubectl get service kourier -n kourier-system 
NAME      TYPE           CLUSTER-IP    EXTERNAL-IP      PORT(S)                      AGE
kourier   LoadBalancer   10.3.15.239   135.125.83.166   80:31357/TCP,443:31782/TCP   2m19s

Avertissement : comme la création du LoadBalancer est asynchrone et que le provisionnement du load balancer peut prendre plusieurs minutes, vous obtiendrez certainement un état <pending> pour le champ EXTERNAL-IP. Réessayez dans quelques minutes pour obtenir l'adresse IP externe.

Conservez cette valeur pour l'utiliser dans la section suivante consacrée à la configuration du DNS.

Vérifier l'installation

Un nouveau namespace knative-serving a été créé sur votre cluster Kubernetes avec les composants Knative Serving ; vérifions que ces composants s'exécutent correctement :

kubectl get pods -n knative-serving

Voici un exemple de résultat :

$ kubectl get pods -n knative-serving
NAME                                     READY   STATUS    RESTARTS   AGE
activator-7c48c6944d-rk6mz               1/1     Running   0          20m
autoscaler-775c659bc6-vnljf              1/1     Running   0          20m
controller-7cf4fbd94-vl8tc               1/1     Running   0          20m
net-kourier-controller-568fb445b-f8kwl   1/1     Running   0          19m
webhook-57ccdb4884-md5jq                 1/1     Running   0          20m

Vous pouvez également vérifier la version installée de Knative Serving :

kubectl get namespace knative-serving -o 'go-template={{index .metadata.labels "app.kubernetes.io/version"}}'

Voici un exemple de résultat :

$ kubectl get namespace knative-serving -o 'go-template={{index .metadata.labels "app.kubernetes.io/version"}}'
1.17.0

Knative Serving version 1.17.0 est correctement déployé dans notre cluster.

Configurer le DNS

Pour ce tutoriel, même si cela n'est pas obligatoire, vous pouvez configurer le DNS afin d'éviter d'avoir à exécuter des commandes curl avec un en-tête d'hôte.

Pour configurer le DNS pour Knative, récupérez l'adresse IP externe obtenue lors de la configuration réseau (135.125.83.166 dans cet exemple) et configurez-la chez votre fournisseur DNS comme suit :

Configurez un enregistrement A générique (wildcard) pour le domaine :

# Here knative.example.com is the domain suffix for your cluster
*.knative.example.com == A 135.125.83.166

Chez OVHcloud, vous pouvez créer une nouvelle entrée dans une zone DNS existante, comme ceci : Nouvelle entrée OVHcloud dans la zone DNS pour Knative

Une fois votre fournisseur DNS configuré, indiquez à Knative d'utiliser ce domaine :

# Replace example.com with your domain suffix
kubectl patch configmap/config-domain \
  --namespace knative-serving \
  --type merge \
  --patch '{"data":{"knative.example.com":""}}'

Pour en savoir plus sur le DNS chez OVHcloud, consultez notre guide sur la configuration d'une zone DNS.

Déployer une application

Pour vérifier que Knative fonctionne réellement dans le cluster, vous allez déployer une application hello-world.

La première chose à faire est de créer un namespace dans lequel nos applications s'exécuteront :

kubectl create namespace knative-apps

Voici un exemple de résultat :

$ kubectl create namespace knative-apps
namespace/knative-apps created

Créez maintenant votre premier fichier Knative Service, nommé service.yaml :

apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: hello-world
spec:
  template:
    spec:
      containers:
      - image: ovhplatform/hello
        ports:
            - containerPort: 80

Comme vous pouvez le constater, le fichier YAML du service Knative est simple et concis.

Il doit être appliqué à notre cluster avec la commande :

kubectl apply -f service.yaml -n knative-apps

Voici un exemple de résultat :

$ kubectl apply -f service.yaml -n knative-apps
service.serving.knative.dev/hello-world created

En interne, Knative a créé plusieurs composants Knative et Kubernetes :

Composants Knative Serving

Un déploiement :

$ kubectl get deployment -n knative-apps
NAME                           READY   UP-TO-DATE   AVAILABLE   AGE
hello-world-00001-deployment   1/1     1            1           8s

Un pod :

$ kubectl get pod -n knative-apps
NAME                                            READY   STATUS    RESTARTS   AGE
hello-world-00001-deployment-797f65cdd9-h47sk   2/2     Running   0          9s

Des services :

$ kubectl get svc -n knative-apps
NAME                        TYPE           CLUSTER-IP    EXTERNAL-IP                                         PORT(S)                                      AGE
hello-world                 ExternalName   <none>        kourier-internal.kourier-system.svc.cluster.local   80/TCP                                       9s
hello-world-00001           ClusterIP      10.3.82.197   <none>                                              80/TCP                                       12s
hello-world-00001-private   ClusterIP      10.3.0.240    <none>                                              80/TCP,9090/TCP,9091/TCP,8022/TCP,8012/TCP   12s

Ainsi qu'un service, une route et une révision Knative :

$ kn service list -n knative-apps
NAME          URL                                                        LATEST              AGE   CONDITIONS   READY   REASON
hello-world   http://hello-world.knative-apps.knative.example.com   hello-world-00001   51s   3 OK / 3     True

$ kn route list -n knative-apps
NAME          URL                                                        READY
hello-world   http://hello-world.knative-apps.knative.example.com   True

$ kn revision list -n knative-apps
NAME                SERVICE       TRAFFIC   TAGS   GENERATION   AGE   CONDITIONS   READY   REASON
hello-world-00001   hello-world   100%             1            58s   4 OK / 4     True

Comme on peut le constater, par défaut, 100 % du trafic est dirigé vers la révision hello-world-00001.

Récupérons maintenant l'URL de la route :

$ kn service describe hello-world -n knative-apps -o url
http://hello-world.knative-apps.example.com

Avec cette information, nous pouvons tester l'appel à notre application :

$ curl http://hello-world.knative-apps.knative.example.com
<!doctype html>

<html>
<head>
<title>OVH K8S</title>
</head>

<body>
<div className="title">
<p>Hello from Kubernetes!</p>
<img src="./ovh.svg"/>
</div>
</body>
</html>

Réduction à zéro (scale to zero)

Une des forces de Knative Serving est l'autoscaling intégré. Cela signifie que votre Knative Service ne démarre votre application pour effectuer son travail que si nécessaire ; sinon, il effectue un « scale to zero » en arrêtant les instances et en attendant qu'une nouvelle requête arrive.

Ainsi, si vous n'envoyez pas de requêtes à votre application, les pods seront automatiquement supprimés !

$ kubectl get po -n knative-apps
No resources found in knative-apps namespace.

Et ensuite ?

Vous disposez désormais d'une application « Hello World » fonctionnelle, déployée sur Knative, sur un cluster OVHcloud Managed Kubernetes. Un prochain tutoriel vous présentera d'autres fonctionnalités intéressantes de Knative, comme la répartition du trafic, le déploiement blue/green et le scaling horizontal.

Dans ce tutoriel, nous n'avons vu que le composant Serving. Si le composant Knative Eventing vous intéresse, nous vous recommandons la documentation officielle.

Suppression (nettoyage)

Si vous le souhaitez, vous pouvez désinstaller les applications Knative, ainsi que les composants Serving et les composants principaux.

Tout d'abord, supprimez notre application Hello World :

kubectl delete -f service.yaml -n knative-apps

Ensuite, supprimez les CRD Knative :

kubectl api-resources -o name | grep knative | xargs kubectl delete crd

Ensuite, supprimez les ressources Knative :

kubectl -n knative-serving delete po,svc,daemonsets,replicasets,deployments,rc,secrets --all
kubectl -n kourier-system delete po,svc,daemonsets,replicasets,deployments,rc,secrets --all

Enfin, supprimez les namespaces :

kubectl delete namespace knative-serving
kubectl delete namespace kourier-system
kubectl delete namespace knative-apps

Aller plus loin

  • Si vous avez besoin d'une formation ou d'une assistance technique pour la mise en oeuvre de nos solutions, contactez votre commercial ou cliquez sur ce lien pour obtenir un devis et demander une analyse personnalisée de votre projet à nos experts de l’équipe Professional Services.

  • Échangez avec notre communauté d'utilisateurs.

Cette page vous a-t-elle aidé ?