Créez un opérateur Kubernetes en 10 minutes avec Operator SDK

À Kubernetes, objets sont analogues à un travail ou à une tâche terminée dans le monde réel. Vous pouvez les utiliser pour définir des tâches courantes, les stocker dans un système de contrôle de version et les appliquer avec kubectl s’applique. Kubernetes s’assure que cela déclenche tout ce qui est nécessaire pour donner vie à votre description déclarative en créant les ressources dépendantes (comme les pods) pour exécuter votre logiciel. Kubernetes contient un certain nombre de types d’objets intégrés qui peuvent être créés avec ce flux de travail, comme les déploiements et les services.

Avec les opérateurs, Kubernetes permet aux responsables de cluster ou aux fournisseurs de logiciels de définir leurs propres types d’objet Kubernetes, appelés définitions de ressources personnalisées (CRD). Ces objets peuvent être gérés par l’API Kubernetes, tout comme les types d’objets intégrés. Dans le code opérateur, les auteurs peuvent définir comment agir sur ces objets personnalisés.

L’utilisateur opérateur peut utiliser kubectl s’applique pour créer un objet de ce type personnalisé, qui est appelé une ressource personnalisée (CR).

Il existe de nombreuses utilisations différentes des CR, du déploiement de quelques pods aux applications plus complexes. Imaginez courir kubectl -f postgres.yml et préparer un cluster PostgreSQL haute disponibilité.

Cet article utilisera un opérateur Kubernetes pour déployer une application simple composée d’une carte de configuration et d’un pod. Dans le CR, vous pouvez spécifier une chaîne Markdown qui sera transformée en une présentation basée sur HTML5. (Après tout, qui ne veut pas préparer les diapositives pour leur prochain discours en utilisant kubectl modifier la présentation ma-présentation, comme vous le ferez dans ce didacticiel?)

Si vous n’êtes pas déjà familiarisé avec l’exécution d’un cluster Kubernetes, lisez Prise en main de Minikube: Kubernetes sur votre ordinateur portable pour faciliter le suivi de ce mode d’emploi.

Installer le SDK opérateur

Avant de commencer, je suppose que vous êtes déjà connecté au cluster Kubernetes que vous souhaitez utiliser. Vous devez également avoir Golang 1.13 ou version ultérieure.

Installez la dernière version d’Operator SDK pour votre ordinateur à partir de la page des versions d’Operator SDK sur GitHub, puis rendez-la exécutable et placez-la dans votre CHEMIN comme operator-sdk:

$ wget https://github.com/cadre opérateur/operator-sdk/communiqués/Télécharger/v0.15.2/operator-sdk-v0.15.2-x86_64-linux-gnu
$ sudo mv operator-sdk-v0.15.2-x86_64-linux-gnu /usr/local/poubelle/operator-sdk
$ sudo chmod + x /usr/local/poubelle/operator-sdk


Bootstrap un nouvel opérateur Kubernetes

Vous êtes maintenant prêt à commencer le développement de l’opérateur! le operator-sdk binaire peut être utilisé pour générer le code passe-partout commun à de nombreux opérateurs différents. Cela permet à chaque auteur d’opérateur de se concentrer sur le développement de sa propre logique qui la différencie des autres opérateurs, au lieu de réinventer la logique d’opérateur encore et encore. Pour générer le code passe-partout, exécutez la commande suivante dans un dossier dans lequel vous souhaitez créer l’opérateur. Operator SDK va générer un dossier avec le nom de l’opérateur que vous spécifiez:

$ CD ~/les opérateurs
$ operator-sdk nouvel opérateur d’exemple de présentation –type aller –repo github.com/NautiluX/présentation-exemple-opérateur


Pointez l’argument repo vers le référentiel que vous souhaitez utiliser pour votre module Go. Cette commande va télécharger certaines dépendances, créer le dossier présentation-exemple-opérateuret créez une configuration de projet de base. Ensuite, générez du code Go pour représenter votre définition de ressource personnalisée (l ‘ »API » de votre opérateur):

$ CD présentation-exemple-opérateur
$ operator-sdk add api –gentil Présentation –api-version presentation.example.com/v1alpha1


Cette commande spécifie que le CRD sera appelé Présentation et crée le fichier pkg / apis / presentation / v1alpha1 / presentation_types.go, que vous pouvez modifier pour spécifier le paramètre d’entrée de votre CRD. Pour cet exemple d’application, vous n’avez besoin que d’un paramètre, appelé Réduction:


type PresentationSpec struct {
// INSERT ADDITIONAL SPEC FIELDS – état souhaité du cluster
// Important: Exécutez « operator-sdk generate k8s » pour régénérer le code après avoir modifié ce fichier
// Ajoutez une validation personnalisée à l’aide des balises kubebuilder: https://book-v1.book.kubebuilder.io/beyond_basics/generating_crd.html

// Ce champ peut être utilisé pour définir votre présentation en démarque. Utilisez — pour séparer les diapositives.
Réduction chaîne `json: » markdown, omitempty « `
}


Notez que les seules choses différentes ici sont un commentaire pour le champ et la déclaration du champ Markdown. Le reste du fichier est généré par Operator SDK et peut être adapté à vos besoins.

Maintenant, générez les CRD réels à partir de cette définition et d’un peu de code Go. Pour ce faire, exécutez les commandes suivantes:

$ operator-sdk génère des crds
$ operator-sdk génère des k8s


Dans deploy / crds / presentation.example.com_presentations_crd.yaml, vous trouverez le CRD, que vous pouvez installer sur votre cluster à l’aide de la commande suivante:

$ kubectl s'applique -F déployer/crds/presentation.example.com_presentations_crd.yaml

L’opérateur exécutera un soi-disant boucle de réconciliation, qui garantit qu’un morceau de code est exécuté chaque fois qu’un CR provenant des CRD d’un opérateur est créé. Ce morceau de code vit dans un contrôleur. Chaque CRD sur lequel l’opérateur souhaite opérer aura un contrôleur correspondant dans l’opérateur. Dans ce cas, vous n’avez besoin que d’un seul contrôleur, car vous n’avez qu’un seul CRD. Il est cependant courant d’avoir plusieurs CRD et plusieurs contrôleurs dans un seul opérateur. Pour créer un contrôleur pour votre CRD nouvellement créé, exécutez la commande suivante:

$ opérateur-sdk ajouter un contrôleur --gentil Présentation --api-version presentation.example.com/v1alpha1

Vous pouvez maintenant ajouter votre propre logique à la fonction Réconcilier dans le fichier généré pkg / controller / add_presentation.go. Cette fonction sera appelée chaque fois qu’un Présentation CR est créé, modifié ou supprimé. Chaque fois qu’il renvoie une erreur, la même demande exécutera un autre tour via cette fonction.

Une fois généré, il contient un exemple de code qui crée un module, que vous pouvez ajuster en fonction de vos besoins. Vous pouvez trouver l’implémentation complète des fonctions appelées dans le référentiel Git de cet exemple d’opérateur. Ce code montre le workflow dans la fonction Réconcilier:


configMapChanged, se tromper : = r.EnsureLatestConfigMap(exemple)
si se tromper ! = néant {
revenir réconcilier.Résultat{}, se tromper
}
se tromper = r.assureLatestPod(exemple, configMapChanged)
si se tromper ! = néant {
revenir réconcilier.Résultat{}, se tromper
}
revenir réconcilier.Résultat{}, néant


Tout d’abord, il garantit l’existence d’un ConfigMap avec le Markdown actuel. Ensuite, il garantit qu’un pod est créé avec la dernière version de ConfigMap montée.

Itérer rapidement: exécuter l’opérateur en dehors du cluster

L’opérateur peut être déployé sur le cluster, comme n’importe quelle autre application. Cependant, pour des itérations rapides pendant le développement, il est pratique de l’exécuter sur votre machine locale. De cette façon, vous pouvez voir la sortie tout de suite et l’arrêter en appuyant simplement sur Ctrl + C. Pour démarrer l’opérateur, exécutez la commande suivante:

$ run opérateur-sdk --local

Vous pouvez maintenant créer votre première présentation à partir d’un terminal séparé et regarder l’opérateur faire son travail:

$ kubectl s’applique -F <(écho  »
apiVersion: presentation.example.com/v1alpha1
genre: Présentation
métadonnées:
nom: exemple-présentation
spec:
démarque: |
# Ma première présentation

## Diapositive de test

* Test

 »

)


Cela fera tourner un pod et créera une carte de configuration, comme vous l’avez défini dans le code Go ci-dessus:

$ kubectl get pods
NOM READY STATUS RESTARTS AGE
exemple-présentation-pod 1/1 Fonctionnement 0 103s

$ kubectl get configmaps
NOM DES DONNÉES ÂGE
exemple-présentation-config 1 104s


Pour accéder à cette petite application et voir vos diapositives, vous devez transférer le port 80 depuis l’intérieur du pod. Dans une application réelle, vous pouvez créer une ressource de service à partir du code opérateur:

$ kubectl port-forward exemple-présentation-pod 8080:80

Vous pouvez maintenant voir votre présentation en naviguant sur votre navigateur pour http: // localhost: 8080. Chaque fois que vous mettez à jour le Markdown (par exemple, en utilisant kubectl modifier la présentation exemple-présentation), la page sera mise à jour après le redéploiement du pod (et vous devrez redémarrer la redirection de port).

Déployer l’opérateur

Pour déployer l’opérateur, vous devez créer une image de conteneur accessible par votre cluster Kubernetes. Heureusement, Operator SDK contient des outils pour créer cette image. Après la construction, vous pouvez pousser l’image avec la CLI Docker:

$ operator-sdk build manueldewald/présentation-exemple-opérateur
$ docker push manueldewald/présentation-exemple-opérateur


Maintenant, vous devez ajuster la configuration de déploiement précédemment générée par le SDK opérateur dans deploy / operator.yaml:

$ sed -je 's | REPLACE_IMAGE | manueldewald / presentation-example-operator | g' déployer/operator.yaml

Enfin, vous pouvez déployer l’opérateur à l’aide de kubectl apply -f deploy / operator.yml, et il commencera à s’exécuter à l’intérieur du cluster. Vous pouvez maintenant essayer de modifier votre présentation ou d’en déployer une nouvelle.

Conclusion

Il est assez simple de créer et de déployer un opérateur personnalisé et des types Kubernetes personnalisés à l’aide du SDK opérateur.

Si vous aimez l’idée de créer des diapositives à l’aide de Markdown, jetez un œil à Remark.js, qui a été utilisé dans cet exemple d’Operator. Vous n’avez pas besoin d’exécuter un cluster Kubernetes pour l’utiliser; l’ouverture d’un simple fichier HTML suffira. Mais si vous souhaitez présenter à partir de votre cluster Kubernetes pour une raison quelconque, vous savez maintenant comment le faire.

Source : https://opensource.com/article/20/3/kubernetes-operator-sdk Traduit de l’anglais sous licence CC BY-SA 4.0

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *