Kubernetes: une solution de projet personnel incroyablement abordable

Bonjour collègues!

En janvier, nous avons enfin le livre tant attendu sur Kubernetes. Discours sur la «Mastering Kubernetes 2nd edition» par Gigi Saifan:


Nous n'avons pas osé publier un livre sur Kubernetes il y a environ un an, car à cette époque la technologie ressemblait définitivement à un dreadnought pour les super corporations. Cependant, la situation est en train de changer, à l'appui de laquelle nous suggérons de lire un grand article de Caleb Doxsey, qui a d'ailleurs écrit un livre sur la langue du Go. Les arguments de M. Doxy sont très intéressants et nous espérons qu'après les avoir lus, vous voudrez vraiment essayer Kubernetes dans la pratique.

J'ai passé quelques mois au début de cette année sur une étude approfondie de Kubernetes: j'en avais besoin pour un projet de travail. Kubernetes est une technologie complète pour la gestion des infrastructures, elle "inclut tout, même les batteries". Kubernetes résout un certain nombre de problèmes que vous êtes condamné à rencontrer lors du développement pour les grandes entreprises. Cependant, la croyance que Kubernetes est une technologie trop sophistiquée qui n'est pertinente que pour la gestion d'un grand cluster de machines est répliquée. Apparemment, la charge opérationnelle lors de l'utilisation de Kubernetes est si grande que son utilisation pour les petites infrastructures, où la machine ne va pas par dizaines, est un tir de canon sur des moineaux.
Je me permets d'être en désaccord avec cela. Kubernetes est également bon pour les petits projets, et aujourd'hui vous pouvez déjà vous permettre votre propre cluster Kubernetes pour moins de 5 $ par mois.

Un mot pour défendre Kubernetes

Ci-dessous, je vais vous montrer comment configurer votre propre cluster Kubernetes, mais essayez d'abord d'expliquer pourquoi Kubernetes devrait être utilisé dans de petits projets:

Kubernetes est minutieux

Oui, à première vue, Kubernetes semble être une solution quelque peu redondante. Il semble plus facile d'obtenir et d'obtenir une machine virtuelle et de ne pas configurer votre propre application en tant que service, pourquoi pas? En choisissant cette voie, vous devrez décider de certaines solutions, notamment:

1. Comment déployer l'application? Il suffit de le resynchroniser sur le serveur?
2. Et les dépendances? Si vous travaillez avec Python ou Ruby, vous devrez les installer sur le serveur. Allez-vous simplement exécuter les commandes manuellement?
3. Comment allez-vous lancer l'application? Exécutez simplement le binaire en arrière-plan, puis rien? Ce n'est probablement pas trop bon, donc si vous organisez l'application en tant que service, vous devez apprendre systemd?
4. Comment allez-vous gérer le fonctionnement de nombreuses applications lorsqu'elles ont toutes des noms de domaine ou des chemins http différents? (vous devez probablement configurer haproxy ou nginx pour cela)
5. Supposons que vous ayez mis à jour votre application. Comment allez-vous alors déployer les changements? Arrêter le service, déployer le code, redémarrer le service? Comment éviter les temps d'arrêt?
6. Et si vous bloquez le déploiement? Il y a des opportunités de revenir en arrière? (Répertoire Symlink ...? Ce script simple ne semble plus particulièrement simple)
7. Votre application utilise-t-elle d'autres services, par exemple, redis? Comment configurer tous ces services?

Kubernetes résout tous ces problèmes. Naturellement, ils sont tous résolus par d'autres moyens, parmi lesquels il existe de meilleures options pour Kubernetes; cependant, il est préférable de ne pas penser à tout cela et de se concentrer sur le développement d'applications.

Kubernetes est fiable

Un seul serveur plantera toujours. Oui, c'est rare, peut-être une fois par an, mais après un tel événement, un vrai mal de tête commence: comment remettre tout en condition de travail. Cela est particulièrement vrai si vous avez manuellement configuré vous-même l'intégralité de la configuration. Rappelez-vous toutes les équipes qui ont couru la dernière fois? Vous souvenez-vous de ce qui a fonctionné sur le serveur? Je me souviens d'une citation de bashorg:

erno: Hmm. Perdu l'ordinateur ... sérieusement, _lost_. Il répond, fonctionne bien, je ne sais pas où il est allé dans l'appartement.
bash.org/?5273

Exactement la même chose m'est arrivée récemment sur mon propre blog. J'avais juste besoin de mettre à jour le lien, mais j'ai complètement oublié comment déployer le blog. Soudain, un correctif de dix minutes s'est transformé en un travail pendant tout un week-end.

Kubernetes utilise un format descriptif , vous savez donc toujours quelles choses, quand et où il était censé s'exécuter; De plus, tous les composants de votre système déployé sont beaucoup plus visibles. De plus, dans le plan de contrôle, la défaillance des nœuds est gérée avec soin et les foyers sont automatiquement redistribués. Lorsque vous travaillez avec un service qui ne conserve pas l'état, par exemple, avec une application Web, vous pouvez probablement oublier complètement les échecs.

Apprendre Kubernetes n'est pas plus difficile que des alternatives

Kubernetes ne suit pas le modèle Unix. Il ne rentre pas dans l'écosystème d'outils. Il ne fait pas partie de ces décisions qui "ne font qu'une chose et le font bien". Kubernetes est une solution complète à de nombreux problèmes, capable de remplacer une variété de trucs et d'outils auxquels les développeurs sont déjà habitués.

Kubernetes a sa propre terminologie, ses propres outils, son propre paradigme de gestion de serveur, qui diffère considérablement de l'approche Unix traditionnelle. Lorsque vous naviguez sur ces systèmes, de nombreuses fonctionnalités de Kubernetes peuvent sembler aléatoires et trop compliquées, voire cruelles. Je suppose qu'il y a de bonnes raisons pour lesquelles cette complexité est apparue, mais ici je ne dis pas que Kubernetes est simple et élémentaire à comprendre; Je dis que les connaissances de Kubernetes suffisent pour créer et prendre en charge n'importe quelle infrastructure.

Cela ne veut pas dire que tout administrateur système possède une formation suffisante sous Unix. Par exemple, après avoir obtenu mon diplôme universitaire, j'ai travaillé pendant 5 ans dans l'écosystème Windows. Je peux dire que mon premier emploi dans une startup où j'avais besoin de traiter avec Linux, a nécessité une transformation difficile. Je ne connaissais pas les commandes de mémoire, je n'ai pas l'habitude d'utiliser la ligne de commande pour presque toutes les occasions. Il m'a fallu un certain temps pour apprendre à travailler avec la nouvelle plate-forme (même si j'avais déjà une certaine expérience en programmation à ce moment-là), mais je me souviens clairement combien j'ai souffert.

Avec Kubernetes, vous pouvez commencer tout le travail à partir de zéro. Dans Kubernetes, vous pouvez facilement provisionner des services même sans connexion SSH au serveur. Vous n'avez pas besoin d'apprendre systemd; il n'est pas nécessaire de comprendre les niveaux d'exécution ni de savoir quelle commande a été utilisée: groupadd ou addgroup ; Vous n'avez pas à apprendre à gérer ps ou, Dieu nous en préserve, vim. Tout ce matériel est utile et important, rien n'en disparaît nulle part. J'ai un grand respect pour les administrateurs système capables de se frayer un chemin à travers n'importe quel environnement Unix. Mais serait-ce cool que les développeurs puissent acquérir de manière productive toutes ces ressources sans se plonger dans de telles subtilités d'administration?

Est-ce vraiment ça:

 [Unit] Description=The NGINX HTTP and reverse proxy server After=syslog.target network.target remote-fs.target nss-lookup.target [Service] Type=forking PIDFile=/run/nginx.pid ExecStartPre=/usr/sbin/nginx -t ExecStart=/usr/sbin/nginx ExecReload=/usr/sbin/nginx -s reload ExecStop=/bin/kill -s QUIT $MAINPID PrivateTmp=true [Install] WantedBy=multi-user.target 

Beaucoup plus difficile que ça?

 apiVersion: apps/v1 kind: Deployment metadata: name: my-nginx spec: selector: matchLabels: run: my-nginx replicas: 1 template: metadata: labels: run: my-nginx spec: containers: - name: my-nginx image: nginx ports: - containerPort: 80 

Et c'est toujours un cas relativement bon. Si vous gérez l'infrastructure à 100% à distance, vous ne pourrez pas fournir de prise en charge manuelle du serveur. Pour ce faire, vous aurez besoin d'une sorte d'outil: ansible, sel, chef, marionnette, etc. Naturellement, pour maîtriser Kubernetes et travailler efficacement avec lui, vous devez apprendre beaucoup, mais ce n'est pas plus difficile que de gérer des alternatives.

Kubernetes open source

À l'ère de l'énorme popularité des technologies sans serveur, Kubernetes se distingue par son indépendance vis-à-vis de fournisseurs spécifiques. Il existe au moins 3 fournisseurs populaires et faciles à gérer de Kubernetes (Google, Amazon, Microsoft) qui ne disparaîtront pas dans un avenir prévisible. Il existe également de nombreuses entreprises qui gèrent avec succès leurs propres clusters Kubernetes, et chaque jour le nombre de ces entreprises se multiplie. Aujourd'hui, travailler avec Kubernetes dès le premier jour est une solution évidente pour la plupart des startups.
Kubernetes, étant un projet open source, est bien documenté, stable et populaire, et tous les problèmes peuvent être traités avec autant de détails que possible sur stackoverflow. Bien sûr, Kubernetes a ses propres bugs et défis techniques, mais je vous assure: il y a des gars dans le monde qui perfectionnent Kubernetes avec une compétence incroyable. Leur travail est vos dividendes; au cours des prochaines années, cette technologie ne fera que s'améliorer.

Écailles Kubernetes

L'un des défis associés à la prise en charge de l'infrastructure est le suivant: les techniques qui sont utiles lors du déploiement de petits systèmes réussissent rarement à se reproduire dans des systèmes plus grands. Il est certainement pratique de lier SCP un fichier binaire au serveur, de tuer le processus et de le redémarrer si vous n'avez qu'un seul serveur. Mais, lorsque vous devez prendre en charge plusieurs serveurs et les surveiller simultanément, une telle tâche peut s'avérer extrêmement difficile. C'est pourquoi vous ne pouvez pas vous passer d'outils comme le chef ou la marionnette lors de la gestion d'une telle infrastructure.

Cependant, si vous choisissez le mauvais outil, au fil du temps, il peut vous conduire dans un coin. Soudain, il s'avère que le chef-serveur leader n'est pas en mesure de faire face à la charge de 1000 serveurs, le déploiement bleu-vert ne correspond pas à votre modèle et il faut des heures pour terminer les tâches capistrano. Lorsque l'infrastructure atteint une certaine taille, vous serez obligé de démolir tout ce qui a déjà été fait et de recommencer. Ce serait formidable si vous pouviez sortir de cette roue d'écureuil éternelle avec une infrastructure et passer à une technologie qui évoluera en fonction de vos besoins?

Kubernetes ressemble beaucoup à une base de données SQL. SQL est le produit de nombreuses années de leçons difficiles sur le stockage de données et l'interrogation efficace. Vous n'aurez probablement jamais besoin d'un dixième de ces fonctionnalités fournies dans une base de données SQL valide. Vous pourriez même être en mesure de concevoir un système plus efficace, en vous appuyant sur votre propre base de données. Mais dans la grande majorité des situations, la base de données SQL ne satisfera pas seulement tous vos besoins, mais augmentera considérablement votre capacité à émettre rapidement des solutions toutes faites. Les schémas SQL et l'indexation sont beaucoup plus faciles à utiliser que les structures de données natives basées sur des fichiers, car les structures de données natives deviendront presque certainement obsolètes à mesure que votre produit grandit et se développe avec le temps. Mais la base de données SQL est susceptible de survivre à toute refactorisation inévitable.

Kubernetes survivra aussi. Peut-être que votre projet parallèle ne se développera jamais à une telle échelle où ses problèmes ne peuvent être résolus qu'avec Kubernetes, mais Kubernetes possède absolument tous les outils pour tous les problèmes, et les compétences que vous acquerrez en traitant de cette boîte à outils peuvent s'avérer être inestimable dans les projets futurs.

Créez votre propre cluster Kubernetes

Je pense donc qu'il est conseillé d'utiliser Kubernetes dans de petits projets, mais seulement si la mise en place d'un cluster se révèle simple et peu coûteuse. Il s'avère que les deux sont réalisables. Il existe des fournisseurs gérés par Kubernetes qui gèrent tout le désordre par eux-mêmes, prenant en charge le plan de contrôle de l'hôte Kubernetes. Et les récentes guerres de dumping dans l'environnement d'infrastructure cloud ont conduit à une réduction étonnante du coût de ces services.
Nous analyserons le cas suivant en utilisant le moteur Kubernetes de Google (GKE) à titre d'exemple, cependant, vous pouvez également consulter les offres d'Amazon (EKS) ou de Microsoft (AKS) si Google ne vous convient pas. Pour créer votre propre cluster Kubernetes, nous avons besoin de:

• Nom de domaine (~ 10 $ / an, selon le domaine)
• Hébergement DNS Cloudflare (gratuit)
• Cluster à trois nœuds GKE Kubernetes (~ 5 $ / mois)
• Application Web téléchargée en tant que conteneur Docker dans le Google Container Registry (GCR) (gratuit)
• Un certain nombre de fichiers yaml pour la configuration de Kubernetes

Pour des économies supplémentaires, nous allons essayer de nous passer d'un contrôleur d'entrée Google. À la place, nous utiliserons Nginx sur chaque nœud comme démon et créerons notre propre opérateur qui synchronisera les adresses IP externes du nœud de travail avec Cloudflare.

Configuration de Google

Tout d'abord, accédez à console.cloud.google.com et créez un projet, si vous ne l'avez pas déjà fait. Vous devrez également créer un compte de facturation. Ensuite, via le menu hamburger, accédez à la page Kubernetes et créez un nouveau cluster. Voici ce que vous devez faire ensuite:

• Sélectionnez Zonal pour le type d'emplacement.
• J'ai indiqué mon emplacement comme us-central1-a
• Choisissez votre version de kubernetes
• Créez un pool de 3 nœuds en utilisant le type d'instance le moins cher (f1-micro).
• Pour ce pool de nœuds, sur l'écran «avancé», définissez la taille du disque de démarrage sur 10 Go, activez les nœuds extrudés (ils sont moins chers), activez la mise à jour automatique et le traitement automatique.
• Sous le pool de nœuds, vous trouverez un certain nombre d'options supplémentaires. Nous voulons désactiver l'équilibrage de charge HTTP (l'équilibrage de charge dans GCP coûte cher), et désactiver également l'ensemble de l'économie associée à StackDriver (il peut également être coûteux et, selon mon expérience, pas très fiable). Éteignez également le panneau indicateur kubernetes.

Après avoir mis toutes ces options, vous pouvez passer à l'étape suivante: créer un cluster. Voici comment économiser dessus:

• Plan de contrôle Kubernetes: gratuit, car Google ne facture pas les nœuds hôtes
• Noeuds de travail Kubernetes: 5,04 $ / mois, en règle générale, 3 micro-noeuds vous coûteront 11,65 $ / mois, et après les avoir évincés, nous réduirons ce taux à 7,67 $ / mois, et toujours gratuit - à 5,04 $.
• Frais de stockage: gratuit. Nous obtenons gratuitement 30 Go d'espace disque permanent, nous avons donc choisi ci-dessus la taille de 10 Go.
• Coûts de l'équilibrage de charge: gratuitement, nous avons désactivé l'équilibrage de charge HTTP, car cela nous coûterait seulement 18 $ / mois. Au lieu de cela, exécutez nos propres proxys HTTP sur chaque nœud et dirigez le DNS vers l'IP publique.
• Frais de réseau: gratuit, la fonction de sortie reste gratuite jusqu'à ce que vous sélectionniez 1 Go par mois. (Ensuite, chaque gigaoctet suivant coûte 8 cents)

Nous avons donc mis en place un cluster Kubernetes de 3 nœuds, cela nous a coûté le même prix que la seule machine Digital Ocean.

En plus de configurer GKE, vous devez également configurer quelques règles de pare-feu afin que vous puissiez atteindre les ports HTTP de nos hôtes depuis le monde extérieur. Recherchez l'entrée VPC Network dans le menu hamburger, puis accédez aux règles de pare-feu et ajoutez les règles pour les ports TCP 80 et 443, avec la plage d'adresses IP 0.0.0.0/0.



Règles de pare-feu

Réglage local

Nous avons donc créé et démarré le cluster, et maintenant configurons-le. Installez l'outil gcloud suivant les instructions sur cloud.google.com/sdk/docs . Après l'avoir installé, vous pouvez procéder à la configuration en procédant comme suit:

 gcloud auth login 

Bien sûr, vous devez toujours installer docker, puis le lier au GCR, afin de pouvoir envoyer des conteneurs:

 gcloud auth configure-docker 

Vous pouvez également installer et configurer kubectl en suivant les instructions décrites ici.

Simplifié:

 gcloud components install kubectl gcloud config set project PROJECT_ID gcloud config set compute/zone COMPUTE_ZONE gcloud container clusters get-credentials CLUSTER_NAME 

Soit dit en passant, c'est juste un conte de fées que toute cette boîte à outils fonctionne sur Windows, OSX ou Linux. En tant que personne qui a parfois fait de telles choses sous Windows, j'avoue que c'est une agréable surprise.

Création d'applications Web

Une application Web peut être écrite dans n'importe quel langage de programmation. Le conteneur vous permet d'abstraire le particulier. Il faut créer une application HTTP à l'écoute sur le port. Je préfère Go à de telles fins, mais pour changer, nous essaierons le cristal. Créez le fichier main.cr :

 # crystal-www-example/main.cr require "http/server" Signal::INT.trap do exit end server = HTTP::Server.new do |context| context.response.content_type = "text/plain" context.response.print "Hello world from crystal-www-example! The time is #{Time.now}" end server.bind_tcp("0.0.0.0", 8080) puts "Listening on http://0.0.0.0:8080" server.listen 

Nous avons également besoin d'un Dockerfile:

 # crystal-www-example/Dockerfile FROM crystallang/crystal:0.26.1 as builder COPY main.cr main.cr RUN crystal build -o /bin/crystal-www-example main.cr --release ENTRYPOINT [ "/bin/crystal-www-example" ] 

Pour créer et tester notre application, exécutez:

 docker build -t gcr.io/PROJECT_ID/crystal-www-example:latest . docker run -p 8080:8080 gcr.io/PROJECT_ID/crystal-www-example:latest 

Et puis allez dans le navigateur localhost: 8080. Après avoir établi ce mécanisme, nous pouvons envoyer notre application à GCR en exécutant:

 docker push gcr.io/PROJECT_ID/crystal-www-example:latest 

Configurer Kubernetes

Ma configuration Kubernetes est ici .

Pour cet exemple, nous devrons créer plusieurs fichiers yaml où nos différents services seront présentés, puis exécuter kubectl apply pour les configurer dans le cluster. La configuration de Kubernetes est descriptive, et tous ces fichiers yaml indiquent à Kubernetes quel état nous voulons obtenir. Au sens large, c'est ce que nous allons faire:

• Créer un déploiement et un service pour notre application Web Crystal-www-example
• Créer un ensemble de démons (ensemble de services) et une carte de configuration (carte de configuration) pour nginx
• Nous lançons notre propre application pour synchroniser les nœuds IP avec Cloudflare for DNS

Configuration d'application Web

Tout d'abord, configurons notre application Web: (assurez-vous de remplacer PROJECT_ID par l'ID de votre projet)

 # kubernetes-config/crystal-www-example.yaml apiVersion: apps/v1 kind: Deployment metadata: name: crystal-www-example labels: app: crystal-www-example spec: replicas: 1 selector: matchLabels: app: crystal-www-example template: metadata: labels: app: crystal-www-example spec: containers: - name: crystal-www-example image: gcr.io/PROJECT_ID/crystal-www-example:latest ports: - containerPort: 8080 --- kind: Service apiVersion: v1 metadata: name: crystal-www-example spec: selector: app: crystal-www-example ports: - protocol: TCP port: 8080 targetPort: 8080 

Cela crée un déploiement (configuration étendue), selon lequel Kubernetes doit créer un seul conteneur (notre conteneur Docker y fonctionnera) et un service que nous utiliserons pour trouver des services dans notre cluster. Pour appliquer cette configuration, exécutez (à partir du kubernetes-config ):

 kubectl apply -f 

Vous pouvez le tester comme ceci:

 kubectl get pod #     : # crystal-www-example-698bbb44c5-l9hj9 1/1 Running 0 5m 

Nous pouvons également créer une API proxy pour l'accès:

 kubectl proxy 

Et puis allez: localhost : 8001 / api / v1 / namespaces / default / services / crystal-www-example / proxy /

Configuration NGINX

En règle générale, lors de l'utilisation de services HTTP, Kubernetes utilise un contrôleur d'entrée. Malheureusement, l'équilibreur de charge HTTP de Google est trop cher, nous ne l'utiliserons donc pas, mais utilisez notre propre proxy HTTP et configurez-le manuellement (cela semble effrayant, mais en réalité, c'est très simple).

Pour ce faire, utilisez Daemon Set et Config Map. Daemon Set est une application qui s'exécute sur chaque nœud. Config Map est, en principe, un petit fichier que nous pouvons monter dans un conteneur; ce fichier stockera la configuration nginx.
Le fichier yaml ressemble à ceci:

 apiVersion: apps/v1 kind: DaemonSet metadata: name: nginx labels: app: nginx spec: selector: matchLabels: app: nginx template: metadata: labels: app: nginx spec: hostNetwork: true dnsPolicy: ClusterFirstWithHostNet containers: - image: nginx:1.15.3-alpine name: nginx ports: - name: http containerPort: 80 hostPort: 80 volumeMounts: - name: "config" mountPath: "/etc/nginx" volumes: - name: config configMap: name: nginx-conf --- apiVersion: v1 kind: ConfigMap metadata: name: nginx-conf data: nginx.conf: | worker_processes 1; error_log /dev/stdout info; events { worker_connections 10; } http { access_log /dev/stdout; server { listen 80; location / { proxy_pass http://crystal-www-example.default.svc.cluster.local:8080; } } } 

C'est ainsi que nous montons le fichier nginx.conf de la carte de configuration dans le conteneur nginx. Nous définissons également des valeurs pour deux autres champs: hostNetwork: true , afin que vous puissiez lier le port hôte et atteindre nginx de l'extérieur et dnsPolicy: ClusterFirstWithHostNet afin que vous puissiez accéder aux services au sein du cluster. Si cela n'est pas fait, nous obtiendrons une configuration complètement standard.

Appliquez ces expressions et vous pouvez accéder à nginx via l'IP publique de vos nœuds.

Voici comment vous pouvez le vérifier:

 kubectl get node -o yaml # look for: # - address: ... # type: ExternalIP 

Alors maintenant, notre application Web est accessible depuis Internet. Reste à trouver un beau nom pour l'application.

Connexion DNS

Il est nécessaire de définir 3 enregistrements DNS A pour les nœuds de notre cluster:



Entrées dans l'interface utilisateur Cloudflare

Ajoutez ensuite un enregistrement CNAME pour pointer vers ces enregistrements A. (par exemple, www.example.com CNAME pour kubernetes.example.com). Cela peut être fait manuellement, mais mieux - automatiquement, de sorte que si nous avons besoin de mettre à l'échelle ou de remplacer des nœuds dans des enregistrements DNS, ces informations sont également mises à jour automatiquement.

Je pense que cet exemple illustre bien comment vous pouvez déléguer une partie de votre travail à Kubernetes, et ne pas essayer de le surmonter. Kubernetes comprend les scripts et possède une API puissante, et vous pouvez remplir les espaces existants avec vos propres composants, qui ne sont pas si difficiles à écrire. Pour ce faire, j'ai réalisé une petite application sur Go, disponible à cette adresse: kubernetes-cloudflare-sync .

Pour commencer, j'ai créé un informateur:

 factory := informers.NewSharedInformerFactory(client, time.Minute) lister := factory.Core().V1().Nodes().Lister() informer := factory.Core().V1().Nodes().Informer() informer.AddEventHandler(cache.ResourceEventHandlerFuncs{ AddFunc: func(obj interface{}) { resync() }, UpdateFunc: func(oldObj, newObj interface{}) { resync() }, DeleteFunc: func(obj interface{}) { resync() }, }) informer.Run(stop) 

Il appellera ma fonction de resynchronisation chaque fois qu'un nœud change. Ensuite, je synchronise l'API à l'aide de la bibliothèque d' API Cloudflare , quelque chose comme ceci:

 var ips []string for _, node := range nodes { for _, addr := range node.Status.Addresses { if addr.Type == core_v1.NodeExternalIP { ips = append(ips, addr.Address) } } } sort.Strings(ips) for _, ip := range ips { api.CreateDNSRecord(zoneID, cloudflare.DNSRecord{ Type: "A", Name: options.DNSName, Content: ip, TTL: 120, Proxied: false, }) } 

Ensuite, comme avec notre application Web, nous lançons cette application dans Kubernetes en tant que déploiement:

 apiVersion: apps/v1 kind: Deployment metadata: name: kubernetes-cloudflare-sync labels: app: kubernetes-cloudflare-sync spec: replicas: 1 selector: matchLabels: app: kubernetes-cloudflare-sync template: metadata: labels: app: kubernetes-cloudflare-sync spec: serviceAccountName: kubernetes-cloudflare-sync containers: - name: kubernetes-cloudflare-sync image: gcr.io/PROJECT_ID/kubernetes-cloudflare-sync args: - --dns-name=kubernetes.example.com env: - name: CF_API_KEY valueFrom: secretKeyRef: name: cloudflare key: api-key - name: CF_API_EMAIL valueFrom: secretKeyRef: name: cloudflare key: email 

Nous devrons créer un secret Kubernetes en spécifiant la cloudflare api et l'adresse postale:

 kubectl create secret generic cloudflare --from-literal=email='EMAIL' --from-literal=api-key='API_KEY' 

Nous devrons également créer un compte de service (donnant à notre déploiement un accès à l'API Kubernetes pour récupérer les nœuds). Première course (en particulier pour GKE):

 kubectl create clusterrolebinding cluster-admin-binding --clusterrole cluster-admin --user YOUR_EMAIL_ADDRESS_HERE 

Et puis appliquez:

 apiVersion: v1 kind: ServiceAccount metadata: name: kubernetes-cloudflare-sync --- apiVersion: rbac.authorization.k8s.io/v1 kind: ClusterRole metadata: name: kubernetes-cloudflare-sync rules: - apiGroups: [""] resources: ["nodes"] verbs: ["list", "watch"] --- apiVersion: rbac.authorization.k8s.io/v1 kind: ClusterRoleBinding metadata: name: kubernetes-cloudflare-sync-viewer roleRef: apiGroup: rbac.authorization.k8s.io kind: ClusterRole name: kubernetes-cloudflare-sync subjects: - kind: ServiceAccount name: kubernetes-cloudflare-sync namespace: default 

Travailler avec RBAC est un peu fastidieux, mais j'espère que tout est clair ici. Lorsque la configuration est prête et que notre application fonctionne avec Cloudflare, cette application peut être mise à jour avec tout changement dans l'un des nœuds.

Conclusion

Kubernetes est destiné à devenir la technologie phare pour la gestion de grands systèmes. , Kubernetes , Kubernetes , Kubernetes , Kubernetes .

, Kubernetes : , . – !