Hé Habr !
En cette fin d'été, nous souhaitons vous rappeler que nous continuons à travailler sur le sujet et a décidé de publier début juin un article de Stackoverflow démontrant l'état des lieux de ce projet.
Bonne lecture!
Au moment de la rédaction de cet article, l’âge de Kubernetes est d’env. , et au cours des deux dernières années, sa popularité a tellement augmenté qu'il est régulièrement classé parmi les plates-formes. Kubernetes se classe troisième cette année. Pour récapituler : Kubernetes est une plate-forme conçue pour exécuter et orchestrer des charges de travail conteneurisées.
Les conteneurs ont commencé comme une conception spéciale pour isoler les processus sous Linux ; les conteneurs incluent depuis 2007 , et depuis 2002 – les espaces de noms. Les conteneurs ont été encore mieux conçus en 2008, lorsqu'ils sont devenus disponibles , et Google a développé son propre mécanisme d'entreprise interne appelé , où « tout le travail est effectué dans des conteneurs ». À partir de là, nous avançons rapidement jusqu’en 2013, lorsque la première version de Docker a eu lieu et que les conteneurs sont finalement devenus une solution de masse populaire. À cette époque, le principal outil d’orchestration de conteneurs était , même s'il n'était pas très populaire. Kubernetes a été lancé pour la première fois en 2015, après quoi cet outil est devenu le standard de facto dans le domaine de l'orchestration de conteneurs.
Pour tenter de comprendre pourquoi Kubernetes est si populaire, essayons de répondre à quelques questions. À quand remonte la dernière fois où les développeurs ont pu se mettre d’accord sur la manière de déployer des applications en production ? Combien de développeurs connaissez-vous qui utilisent les outils tels qu’ils sont fournis ? Combien d’administrateurs cloud aujourd’hui ne comprennent pas le fonctionnement des applications ? Nous examinerons les réponses à ces questions dans cet article.
Infrastructure en tant que YAML
Dans le monde qui est passé de Puppet et Chef à Kubernetes, l'un des changements les plus importants a été le passage de « l'infrastructure en tant que code » à « l'infrastructure en tant que données », plus précisément, comme YAML. Toutes les ressources de Kubernetes, qui incluent les pods, les configurations, les instances déployées, les volumes, etc., peuvent être facilement décrites dans un fichier YAML. Par exemple:
apiVersion: v1
kind: Pod
metadata:
name: site
labels:
app: web
spec:
containers:
- name: front-end
image: nginx
ports:
- containerPort: 80Cette vue permet aux professionnels DevOps ou SRE d'exprimer pleinement leurs charges de travail sans avoir à écrire du code dans des langages comme Python ou Javascript.
Les autres avantages de l’organisation de l’infrastructure sous forme de données incluent :
- Contrôle de version GitOps ou Git Operations. Cette approche vous permet de conserver tous les fichiers YAML Kubernetes dans des référentiels git, afin que vous puissiez suivre exactement quand une modification a été apportée, qui l'a effectuée et ce qui a exactement changé. Cela augmente la transparence des opérations dans toute l'organisation et améliore l'efficacité opérationnelle en éliminant toute ambiguïté, en particulier quant à l'endroit où les employés doivent rechercher les ressources dont ils ont besoin. Dans le même temps, il devient plus facile d’apporter automatiquement des modifications aux ressources Kubernetes en fusionnant simplement une pull request.
- Évolutivité. Lorsque les ressources sont définies au format YAML, il devient extrêmement facile pour les opérateurs de cluster de modifier un ou deux nombres dans une ressource Kubernetes, modifiant ainsi son évolution. Kubernetes fournit un mécanisme de mise à l'échelle automatique horizontale des pods, qui peut être utilisé pour déterminer facilement le nombre minimum et maximum de pods requis dans une configuration de déploiement particulière pour gérer des niveaux de trafic faibles et élevés. Par exemple, si vous avez déployé une configuration qui nécessite une capacité supplémentaire en raison d'un pic soudain de trafic, maxReplicas peut être modifié de 10 à 20 :
apiVersion: autoscaling/v2beta2
kind: HorizontalPodAutoscaler
metadata:
name: myapp
namespace: default
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: myapp-deployment
minReplicas: 1
maxReplicas: 20
metrics:
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 50- Sécurité et gestion. YAML est idéal pour évaluer la manière dont les éléments sont déployés dans Kubernetes. Par exemple, un problème de sécurité majeur concerne le fait de savoir si vos charges de travail s'exécutent en tant qu'utilisateur non administrateur. Dans ce cas, nous pouvons avoir besoin d'outils tels que , validateur YAML/JSON, plus , un validateur de politique pour garantir que le contexte vos charges de travail ne permettent pas au conteneur de s'exécuter avec les privilèges d'administrateur. Si cela est nécessaire, les utilisateurs peuvent appliquer une stratégie simple , comme ceci:
package main
deny[msg] {
input.kind = "Deployment"
not input.spec.template.spec.securityContext.runAsNonRoot = true
msg = "Containers must not run as root"
}- Options d'intégration avec un fournisseur de cloud. L'une des tendances les plus notables de la haute technologie actuelle consiste à exécuter des charges de travail sur des fournisseurs de cloud public. Utilisation du composant Kubernetes permet à n'importe quel cluster de s'intégrer au fournisseur de cloud sur lequel il s'exécute. Par exemple, si un utilisateur exécute une application dans Kubernetes sur AWS et souhaite exposer cette application via un service, le fournisseur de cloud aide à créer automatiquement le service.
LoadBalancerqui fournira automatiquement l'équilibreur de charge pour rediriger le trafic vers les modules d'application.
Extensibilité
Kubernetes est très extensible et les développeurs l'adorent. Il existe un ensemble de ressources disponibles telles que des pods, des déploiements, StatefulSets, secrets, ConfigMaps, etc. Certes, les utilisateurs et les développeurs peuvent ajouter d'autres ressources sous la forme .
Par exemple, si nous voulons définir une ressource CronTab, alors vous pourriez faire quelque chose comme ceci :
apiVersion: apiextensions.k8s.io/v1
kind: CustomResourceDefinition
metadata:
name: crontabs.my.org
spec:
group: my.org
versions:
- name: v1
served: true
storage: true
Schema:
openAPIV3Schema:
type: object
properties:
spec:
type: object
properties:
cronSpec:
type: string
pattern: '^(d+|*)(/d+)?(s+(d+|*)(/d+)?){4}$'
replicas:
type: integer
minimum: 1
maximum: 10
scope: Namespaced
names:
plural: crontabs
singular: crontab
kind: CronTab
shortNames:
- ct
Plus tard, nous pouvons créer une ressource CronTab quelque chose comme ceci :
apiVersion: "my.org/v1"
kind: CronTab
metadata:
name: my-cron-object
spec:
cronSpec: "* * * * */5"
image: my-cron-image
replicas: 5
Une autre option d'extensibilité dans Kubernetes est que le développeur peut écrire ses propres déclarations. est un processus spécial dans le cluster Kubernetes qui fonctionne selon le « " Avec l'aide d'un opérateur, l'utilisateur peut automatiser la gestion des CRD (définitions de ressources personnalisées) en échangeant des informations avec l'API Kubernetes.
Il existe plusieurs outils dans la communauté qui permettent aux développeurs de créer facilement leurs propres opérateurs. Parmi eux - et . Ce SDK fournit une base à partir de laquelle un développeur peut rapidement commencer à créer un opérateur. Disons que vous pouvez démarrer à partir de la ligne de commande quelque chose comme ceci :
$ operator-sdk new my-operator --repo github.com/myuser/my-operatorCela crée tout le code passe-partout pour votre opérateur, y compris les fichiers YAML et le code Golang :
.
|____cmd
| |____manager
| | |____main.go
|____go.mod
|____deploy
| |____role.yaml
| |____role_binding.yaml
| |____service_account.yaml
| |____operator.yaml
|____tools.go
|____go.sum
|____.gitignore
|____version
| |____version.go
|____build
| |____bin
| | |____user_setup
| | |____entrypoint
| |____Dockerfile
|____pkg
| |____apis
| | |____apis.go
| |____controller
| | |____controller.goEnsuite, vous pouvez ajouter les API et le contrôleur requis, comme ceci :
$ operator-sdk add api --api-version=myapp.com/v1alpha1 --kind=MyAppService
$ operator-sdk add controller --api-version=myapp.com/v1alpha1 --kind=MyAppServicePuis enfin, assemblez l'opérateur et envoyez-le au registre de votre conteneur :
$ operator-sdk build your.container.registry/youruser/myapp-operator
Si le développeur souhaite encore plus de contrôle, le code passe-partout dans les fichiers Go peut être modifié. Par exemple, pour modifier les spécificités du contrôleur, vous pouvez apporter des modifications au fichier controller.go.
Un autre projet , vous permet de créer des instructions en utilisant uniquement des fichiers YAML déclaratifs. Par exemple, un opérateur pour Apache Kafka serait défini approximativement . Avec lui, vous pouvez installer un cluster Kafka sur Kubernetes avec seulement quelques commandes :
$ kubectl kudo install zookeeper
$ kubectl kudo install kafkaEt puis configurez-le avec une autre commande :
$ kubectl kudo install kafka --instance=my-kafka-name
-p ZOOKEEPER_URI=zk-zookeeper-0.zk-hs:2181
-p ZOOKEEPER_PATH=/my-path -p BROKER_CPUS=3000m
-p BROKER_COUNT=5 -p BROKER_MEM=4096m
-p DISK_SIZE=40Gi -p MIN_INSYNC_REPLICAS=3
-p NUM_NETWORK_THREADS=10 -p NUM_IO_THREADS=20
Innovations
Au cours des dernières années, des versions majeures de Kubernetes ont été publiées tous les quelques mois, soit trois à quatre versions majeures par an. Le nombre de nouvelles fonctionnalités introduites dans chacun d’eux ne diminue pas. De plus, il n’y a aucun signe de ralentissement, même en ces temps difficiles – regardez quelle est la situation actuelle. .
De nouvelles fonctionnalités vous permettent de regrouper de manière plus flexible les opérations sur diverses charges de travail. De plus, les programmeurs bénéficient d’un plus grand contrôle lors du déploiement d’applications directement en production.
Communauté
Un autre aspect majeur de la popularité de Kubernetes est la force de sa communauté. En 2015, après avoir atteint la version 1.0, Kubernetes a été sponsorisé par .
Il existe également diverses communautés (Groupes d'intérêt spécial) se sont concentrés sur le travail sur différents domaines de Kubernetes à mesure que le projet évolue. Ces groupes ajoutent constamment de nouvelles fonctionnalités, rendant le travail avec Kubernetes plus pratique et plus pratique.
La Cloud Native Foundation héberge également CloudNativeCon/KubeCon, qui, au moment de la rédaction de cet article, est la plus grande conférence open source au monde. Organisé généralement trois fois par an, il rassemble des milliers de professionnels souhaitant améliorer Kubernetes et son écosystème, ainsi que découvrir les nouvelles fonctionnalités qui apparaissent tous les trois mois.
De plus, Cloud Native Foundation a , qui, en collaboration avec les SIG, examine les projets nouveaux et existants des fonds axés sur l’écosystème cloud. La plupart de ces projets contribuent à améliorer les atouts de Kubernetes.
Enfin, je pense que Kubernetes ne connaîtrait pas autant de succès sans les efforts conscients de l’ensemble de la communauté, où les gens se serrent les coudes tout en accueillant les nouveaux arrivants.
L'avenir
L'un des principaux défis auxquels les développeurs devront faire face à l'avenir est la capacité de se concentrer sur les détails du code lui-même, et non sur l'infrastructure dans laquelle il s'exécute. Il répond à ces tendances , qui est l'un des leaders aujourd'hui. Des frameworks avancés existent déjà, par ex. и , qui utilisent Kubernetes pour extraire l'infrastructure du développeur.
Dans cet article, nous n’avons fait qu’effleurer la surface de l’état actuel de Kubernetes ; en fait, ce n’est que la pointe de l’iceberg. Les utilisateurs de Kubernetes disposent de nombreuses autres ressources, capacités et configurations.
Source: habr.com