Nous avons ajouté la possibilité de lancer facilement Kubernetes dans le service Virtual Private Cloud en mode de test bêta précoce.
Cette fonctionnalité sera utile aux utilisateurs qui ont besoin d'une gestion pratique d'un grand nombre d'applications exécutées en tant que conteneurs. Kubernetes propose des outils de mise à l'échelle, d'autoréparation et d'équilibrage de charge pour les conteneurs exécutés à l'intérieur d'un cluster.
Étant donné que le service Virtual Private Cloud est basé sur OpenStack, nous utilisons l'un de ses composants - OpenStack Magnum . Il vous permet de créer rapidement des clusters Kubernetes privés avec le nombre de nœuds souhaité.
Actuellement, tout utilisateur de notre service peut créer plusieurs clusters indépendants dans son projet. En tant que nœuds de cluster, des machines virtuelles seront utilisées, dont la configuration peut être sélectionnée et modifiée.
Dans cet article, nous parlerons des principaux objets du cluster Kubernetes et utiliserons les exemples pour examiner le processus de création d'un cluster à l'aide d'OpenStack Magnum.
Créer et gérer un cluster Kubernetes
Actuellement, la création d'un cluster Kubernetes n'est possible que via les utilitaires de console ou l' API OpenStack dans les zones de disponibilité ru-1a et ru-1b (Saint-Pétersbourg).
Pour commencer, vous aurez besoin de:
- Créer un nouveau ou utiliser un projet VPC existant;
- Créez un utilisateur avec une clé SSH ;
- Ajoutez un utilisateur au projet créé sur la page de gestion de projet;
- Accédez au projet et récupérez le fichier d'accès dans l'onglet Accès ;
- Installez le client de console openstack avec la bibliothèque python-magnumclient ;
- Installez le client de console kubectl .
Pour installer le client de console openstack , vous pouvez utiliser les instructions sur le lien , cependant, il convient de garder à l'esprit que pour ce client, vous devrez également installer la bibliothèque python-magnumclient pour prendre en charge la création de clusters Kubernetes.
L'ensemble complet de commandes pour installer un client openstack avec le plug-in requis pour les systèmes d'exploitation de la famille Ubuntu / Debian:
$ sudo apt update $ sudo apt -y install curl python-pip python-dev python3-dev git libxml2-dev libxslt1-dev python-openssl python3-openssl python-pyasn1 libffi-dev libssl-dev build-essential $ sudo pip install -UI pbr setuptools pytz $ sudo pip install -UI git+https://github.com/openstack/python-openstackclient $ sudo pip install -UI git+https://github.com/openstack/python-magnumclient
L'ensemble complet de commandes pour installer un client openstack avec le plug-in requis pour les systèmes d'exploitation de la famille Fedora / CentOS:
$ sudo yum -y install python-pip gcc libffi-devel python-devel libxslt-devel openssl-devel git libffi-devel $ sudo pip install -UI pbr setuptools pytz $ sudo pip install -UI git+https://github.com/openstack/python-openstackclient $ sudo pip install -UI git+https://github.com/openstack/python-magnumclient
Pour gérer les objets Kubernetes, vous avez besoin du client de console kubectl . Les méthodes d'installation de divers systèmes d'exploitation sont décrites dans la documentation officielle .
Pour créer un cluster, vous devrez créer ou utiliser ceux existants:
- Modèle de cluster;
- Un ensemble de paramètres pour le CPU et la RAM des machines virtuelles (version).
Vous pouvez créer un modèle de cluster et un arôme vous-même, ou utiliser des modèles publics pré-créés.
Vous devrez également déterminer la zone de disponibilité, le type de disques pour votre cluster et le nombre de nœuds. Il convient de noter que nous ne prenons pas encore en charge la possibilité de créer un cluster dans plusieurs zones. Vous pouvez choisir n'importe quel type de lecteur réseau (rapide, universel ou basique).
Vous pouvez en savoir plus sur les types de lecteurs dans notre base de connaissances .
Le nombre de nœuds peut être différent pour les rôles maître et pour les sbires . Sur les nœuds jouant le rôle de maître, les éléments de contrôle du cluster seront lancés - contrôleur-gestionnaire , ordonnanceur , api . Sur les autres nœuds, les services kubelet , kube-proxy et tous les conteneurs d'application seront lancés. Vous pouvez en savoir plus sur les composants qui s'exécutent sur les nœuds de cluster à partir de la documentation officielle .
Pour accéder aux nœuds via SSH, vous devrez utiliser la clé SSH créée précédemment. Les exemples de commandes utiliseront une clé appelée ssh-test .
Nous utiliserons le modèle et la saveur de cluster public, le type de disque rapide et la zone de disponibilité ru-1b .
Dans notre cluster, 2 nœuds maîtres et 3 nœuds sbires seront initialement lancés.
Pour vérifier ces paramètres, nous utilisons les commandes openstackclient et le fichier d'accès téléchargé ( rc.sh ):
Par exemple, nous choisirons le deuxième modèle de cluster; les adresses flottantes accessibles au public pour chacun des nœuds ne seront pas créées à partir de celui-ci. Nous n'en aurons pas besoin.
# Kubernetes test-cluster # keypair , $ openstack coe cluster create \ --cluster-template kubernetes-nofloatingips-ru-1b-v1.9.9 \ --master-count 2 \ --node-count 3 \ --keypair ssh-test \ --master-flavor BL1.2-4096 \ --flavor BL1.2-4096 \ test-cluster
Veuillez noter que nous avons choisi la même configuration pour différents nœuds (maître-saveur et paramètres de saveur), vous pouvez choisir différents jeux de configuration en fonction des exigences du cluster. Leur changement est possible après sa création.
Il convient également de noter que lors de la création d'un cluster avec plusieurs nœuds maîtres, un équilibreur de charge sera automatiquement créé pour accéder à l'API Kubernetes.
Après quelques minutes, un cluster Kubernetes apparaîtra dans votre projet. Dans le panneau de configuration du projet, vous verrez de nouvelles machines virtuelles, disques et objets réseau.
Vous pouvez vérifier l'état de votre cluster via openstackclient:
openstack coe cluster list -c name -c status +--------------+--------------------+ | name | status | +--------------+--------------------+ | test-cluster | CREATE_IN_PROGRESS | +--------------+--------------------+
Une fois que le cluster est entré dans l'état CREATE_COMPLETE, vous pouvez gérer ses objets via l'utilitaire kubectl en téléchargeant le fichier de configuration à l'aide des commandes suivantes:
$ mkdir -p ~/test-cluster $ openstack coe cluster config test-cluster --dir ~/test-cluster
Après cela, vous pouvez travailler avec le cluster à l'aide de l'utilitaire kubectl:
$ export KUBECONFIG=~/test-cluster/config $ kubectl get pods --all-namespaces -o=custom-columns=NAME:.metadata.name,STATUS:.status.phase NAME STATUS coredns-785dcf9c58-6gnfp Running heapster-6846cdc674-rm4k6 Running kube-dns-autoscaler-6b94f7bbf8-x5clt Running kubernetes-dashboard-747575c864-wlg6p Running monitoring-grafana-84b4596dd7-zf5rx Running monitoring-influxdb-c8486fc95-bqqb6 Running node-exporter-test-cluster-robvp4cvwpt7-minion-0 Running
Si nécessaire, vous pouvez augmenter ou diminuer le nombre de nœuds Minion dans le cluster via openstackclient en transmettant la nouvelle valeur node_count:
$ openstack coe cluster update test-cluster replace node_count=4
Objets clés du cluster Kubernetes
Pods
Bien que Kubernetes gère un ensemble de conteneurs, l'entité sous-jacente que Kubernetes gère n'est pas un conteneur, mais un pod .
Pod est un ensemble d'espaces de noms de noyau Linux et de paramètres de pile réseau qui vous permettent d'assembler un ensemble de conteneurs en une seule entité.
Le plus souvent, un conteneur avec l'application est lancé dans un pod distinct.
Si nécessaire, vous pouvez exécuter plusieurs conteneurs à l'intérieur d'un pod, cela peut être utile lorsque vous devez fournir un accès d'un conteneur à un autre via l'interface réseau localhost, ou pour une autre raison, exécuter plusieurs conteneurs sur le même hôte.
Tous les conteneurs exécutés dans le même pod auront un nom d'hôte, une adresse IP, une table de routage et des disques.
Il convient de noter que lors de la mise à l'échelle du nombre d'instances de votre application dans Kubernetes, il est nécessaire d'augmenter le nombre de pods, et non le nombre de conteneurs dans un pod spécifique.
Plus de détails dans la documentation officielle des Pods .
Par exemple, créez le pod le plus simple avec Nginx en utilisant la description au format yaml:
Pour créer un pod, nous pouvons utiliser l'utilitaire kubectl .
Nous avons ajouté tous les exemples présentés dans l'article à notre groupe Github , vous ne pouvez donc pas créer de fichiers sur votre ordinateur, mais utilisez l'url du fichier à partir du référentiel public:
$ kubectl create \ -f https://raw.githubusercontent.com/selectel/kubernetes-examples/master/pods/nginx-basic.yaml
Après la création, nous pouvons demander des informations complètes sur l'état du pod à l'aide de la commande kubectl describe:
$ kubectl describe pod nginx Name: nginx Namespace: default Node: test-cluster-nd5c5y6lsfxb-minion-0/10.0.0.5 Start Time: Sun, 17 Jun 2018 12:29:03 +0000 Labels: <none> Annotations: <none> Status: Running IP: 10.100.88.9 Containers: nginx: Container ID: docker://6ca6383b66686c05c61c1f690737110e0f8994eda393f44a7ebfbbf2b2026267 Image: library/nginx:1.14-alpine Image ID: docker-pullable://docker.io/nginx@sha256:944b79ca7dbe456ce72e73e70816c1990e39967c8f010349a388c00b77ec519c Port: 80/TCP Host Port: 0/TCP State: Running Started: Sun, 17 Jun 2018 12:29:16 +0000 Ready: True Restart Count: 0 Environment: <none> Mounts: /var/run/secrets/kubernetes.io/serviceaccount from default-token-rp5ls (ro) Conditions: Type Status Initialized True Ready True PodScheduled True Volumes: default-token-rp5ls: Type: Secret (a volume populated by a Secret) SecretName: default-token-rp5ls Optional: false QoS Class: BestEffort Node-Selectors: <none> Tolerations: <none> Events: Type Reason Age From Message ---- ------ ---- ---- ------- Normal Scheduled 52s default-scheduler Successfully assigned nginx to test-cluster-nd5c5y6lsfxb-minion-0 Normal SuccessfulMountVolume 51s kubelet, test-cluster-nd5c5y6lsfxb-minion-0 MountVolume.SetUp succeeded for volume "default-token-rp5ls" Normal Pulling 50s kubelet, test-cluster-nd5c5y6lsfxb-minion-0 pulling image "library/nginx:1.14-alpine" Normal Pulled 39s kubelet, test-cluster-nd5c5y6lsfxb-minion-0 Successfully pulled image "library/nginx:1.14-alpine" Normal Created 39s kubelet, test-cluster-nd5c5y6lsfxb-minion-0 Created container Normal Started 39s kubelet, test-cluster-nd5c5y6lsfxb-minion-0 Started container
Comme vous pouvez le voir, Pod a démarré sur un nœud nommé test-cluster-nd5c5y6lsfxb-minion-0 et a reçu une adresse IP interne de 10.100.88.9.
Dans la section Événements, vous pouvez voir les principaux événements de lancement - sélectionner un nœud pour lancer et télécharger l'image.
Nous pouvons entrer dans le Pod et vérifier l'état des processus à l'intérieur du conteneur:
$ kubectl exec -it nginx sh ps aux PID USER TIME COMMAND 1 root 0:00 nginx: master process nginx -g daemon off; 7 nginx 0:00 nginx: worker process 20 root 0:00 sh 24 root 0:00 ps aux exit
Il convient de garder à l'esprit que l'adresse IP 10.100.88.9 ne sera pas disponible pour d'autres applications à l'intérieur et à l'extérieur du cluster Kubernetes, l'accès au Nginx en cours d'exécution ne sera possible qu'à partir du pod lui-même:
$ ping -c 1 10.100.88.9 PING 10.100.88.9 (10.100.88.9): 56 data bytes --- 10.100.88.9 ping statistics --- 1 packets transmitted, 0 packets received, 100% packet loss $ kubectl exec nginx -- ping -c1 10.100.88.9 PING 10.100.88.9 (10.100.88.9): 56 data bytes 64 bytes from 10.100.88.9: seq=0 ttl=64 time=0.075 ms --- 10.100.88.9 ping statistics --- 1 packets transmitted, 1 packets received, 0% packet loss round-trip min/avg/max = 0.075/0.075/0.075 ms
Outre le fait que l'adresse IP spécifiée n'est accessible que depuis le conteneur, elle n'est pas non plus permanente. Cela signifie que si ce pod est recréé, il peut obtenir une adresse IP différente.
Pour résoudre ces problèmes, vous pouvez utiliser un objet appelé Service.
Les services
Le service vous permet d'attribuer des adresses IP permanentes aux pods, de leur fournir l'accès à partir de réseaux externes et d'équilibrer les demandes entre les pods.
Vous pouvez en savoir plus sur Service dans la documentation officielle .
Par exemple, nous devons supprimer le pod en cours d'exécution:
$ kubectl delete pod nginx
Ajoutez Ă la description du pod une Ă©tiquette (Ă©tiquette), qui est requise pour le service:
Nous aurons Ă©galement besoin d'une description du service:
Créer un pod et un service:
$ kubectl create \ -f https://raw.githubusercontent.com/selectel/kubernetes-examples/master/pods/nginx-labeled.yaml \ -f https://raw.githubusercontent.com/selectel/kubernetes-examples/master/services/nginx-nodeport.yaml
Étant donné que le service créé est de type NodePort, le port 30001 indiqué par nous sur toutes les interfaces réseau sera ouvert sur tous les nœuds du cluster.
Cela signifie que si nous ajoutons une adresse IP externe à n'importe quel nœud, nous pouvons accéder au pod en cours d'exécution avec Nginx à partir d'un réseau externe.
Afin de ne pas utiliser les adresses externes des nœuds de cluster pour accéder au service, nous pouvons utiliser le type LoadBalancer au lieu de NodePort.
Nous aurons besoin d'une nouvelle description du service:
Supprimez le service actuel et appliquez la nouvelle description:
$ kubectl delete service nginx-service $ kubectl create \ -f https://raw.githubusercontent.com/selectel/kubernetes-examples/master/services/nginx-loadbalancer.yaml
Après le démarrage du service, Nginx sera disponible sur le port TCP 80 à partir d'un réseau externe, et il ne sera pas nécessaire d'attribuer et d'utiliser des adresses externes pour les nœuds de cluster. Le service de type LoadBalancer allouera automatiquement une nouvelle adresse externe à votre projet VPC et commencera à l'utiliser.
Vous pouvez obtenir des informations sur l'adresse externe en surbrillance Ă l'aide de kubectl:
$ kubectl get service nginx-service -o=custom-columns=IP:status.loadBalancer.ingress[0].ip IP xxx.xxx.xxx.xxx
Dans nos exemples, un seul Pod a été lancé avec Nginx. Pour faire évoluer l'application sur plusieurs pods, nous pouvons utiliser le déploiement.
DĂ©ploiements
Le déploiement est l'essence même du cluster Kubernetes, qui vous permet de faire évoluer les pods et de mettre à jour ou de restaurer facilement les versions d'un grand nombre de pods.
Au lieu du déploiement, vous pouvez également utiliser l'objet ReplicaSet, mais nous ne le toucherons pas dans nos exemples.
Vous pouvez en savoir plus sur le déploiement dans la documentation officielle .
Nous devrons Ă nouveau retirer le Pod (nous n'avons pas besoin de supprimer le Service):
$ kubectl delete pod nginx
Ajoutez la description de déploiement suivante:
Créez le déploiement spécifié:
$ kubectl create -f \ https://raw.githubusercontent.com/selectel/kubernetes-examples/master/deployments/nginx-1.14.yaml
Nous avons choisi 10 pour le paramètre des répliques, donc 10 Pods avec l'application Nginx seront créés dans notre cluster:
$ kubectl get pods --selector app=webservice NAME READY STATUS RESTARTS AGE nginx-deployment-54bfdc4489-42rrb 1/1 Running 0 4m nginx-deployment-54bfdc4489-5lvtc 1/1 Running 0 4m nginx-deployment-54bfdc4489-g7rk2 1/1 Running 0 4m nginx-deployment-54bfdc4489-h5rxp 1/1 Running 0 4m nginx-deployment-54bfdc4489-l9l2d 1/1 Running 0 4m nginx-deployment-54bfdc4489-pjpvg 1/1 Running 0 4m nginx-deployment-54bfdc4489-q8dnp 1/1 Running 0 4m nginx-deployment-54bfdc4489-s4wzf 1/1 Running 0 4m nginx-deployment-54bfdc4489-tfxf9 1/1 Running 0 4m nginx-deployment-54bfdc4489-xjzb5 1/1 Running 0 4m
Vous pouvez accéder à l'application en cours d'exécution à partir du réseau externe à l'aide du service créé dans la section précédente. Le service équilibrera automatiquement les demandes provenant du réseau externe entre 10 instances Nginx.
Si nécessaire, nous pouvons mettre à jour la version de Nginx. Mettez à jour la description du déploiement en changeant la version de l'image de 1.14-alpine à 1.15-alpine:
Pour démarrer le processus de mise à jour des pods, nous utilisons la commande kubectl. Faites attention à l'argument --record, il nous est utile pour la restauration pratique ultérieure de la version Nginx:
$ kubectl apply -f \ https://raw.githubusercontent.com/selectel/kubernetes-examples/master/deployments/nginx-1.15.yaml \ --record
Vous pouvez surveiller la progression de la mise Ă jour Ă l'aide de la commande suivante:
$ kubectl rollout status deployment nginx-deployment Waiting for rollout to finish: 4 out of 10 new replicas have been updated...
Kubernetes attendra 10 secondes après la mise à jour réussie d'un pod, car nous avons spécifié une valeur de 10 pour le paramètre minReadySeconds dans la description du déploiement.
Une fois la mise à jour terminée, tous les pods pour le déploiement passeront à l'état actif:
$ kubectl get deployment --selector app=webservice NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE nginx-deployment 10 10 10 10 23m
Nous pouvons restaurer la version de l'application en cas de problème. Pour ce faire, nous devons sélectionner la révision de déploiement souhaitée:
$ kubectl rollout history deployment nginx-deployment deployments "nginx-deployment" REVISION CHANGE-CAUSE 1 <none> 2 kubectl apply --filename=https://raw.githubusercontent.com/selectel/kubernetes-examples/master/deployments/nginx-1.15.yaml --record=true
Il y a 2 révisions dans la sortie de la commande - la première est la création initiale de Déploiement, la seconde est une mise à jour. Puisque nous avons utilisé l'argument --record lors de la mise à jour, nous voyons la commande qui a créé la deuxième révision de Deployment.
Pour restaurer la version, utilisez la commande suivante:
$ kubectl rollout undo deployment nginx-deployment --to-revision=1
De mĂŞme avec la mise Ă jour, nous pouvons surveiller la restauration de la version en utilisant la commande:
$ kubectl rollout status deployment nginx-deployment Waiting for rollout to finish: 6 out of 10 new replicas have been updated…
Dans tous nos exemples, nous avons utilisé des conteneurs sans magasin de données persistant. Dans la section suivante, nous allons le corriger.
Stockage de données
Par défaut, toutes les données des conteneurs exécutés à l'intérieur des pods sont éphémères et seront perdues lorsque les pods plantent.
Vous pouvez utiliser l'objet PersistentVolumeClaim pour exécuter des pods avec un entrepôt de données persistant.
La création d'un tel objet dans un cluster est très simple - ajoutez simplement sa description, semblable à la façon dont nous avons créé Pod, Service ou Deployment dans les sections précédentes.
Plus d'informations peuvent être trouvées dans la documentation officielle .
Exemple de description de PersistentVolumeClaim créant un disque de 10 Go:
apiVersion: v1 kind: PersistentVolumeClaim metadata: name: my-pv-claim spec: accessModes: - ReadWriteOnce resources: requests: storage: 10Gi
Nous pouvons le connecter en tant que disque à notre Pod en mettant à jour la description de Pod avec Nginx créée précédemment:
Cependant, pour que le disque soit créé, vous devrez spécifier les propriétés du disque créé sous la forme de StorageClass. Dans le service "Virtual Private Cloud", vous pouvez utiliser des lecteurs réseau de types rapides, universels et basiques comme stockage permanent des données Kubernetes Pod.
Par exemple, pour créer une StorageClass qui vous permet d'utiliser des disques rapides dans la zone de disponibilité ru-1b, vous avez besoin de la description suivante:
Avant de créer les objets spécifiés, supprimez le déploiement créé précédemment:
$ kubectl delete deployment nginx-deployment
Tout d'abord, créons une StorageClass, donc elle deviendra la classe par défaut, et PersistentVolumeClaim créé plus tard l'utilisera:
$ kubectl create -f \ https://raw.githubusercontent.com/selectel/kubernetes-examples/master/storageclasses/fast.ru-1b.yaml
Créez PersistentVolumeClaim et Pod:
$ kubectl create \ -f https://raw.githubusercontent.com/selectel/kubernetes-examples/master/persistentvolumeclaims/my-pv-claim.yaml \ -f https://raw.githubusercontent.com/selectel/kubernetes-examples/master/pods/nginx-with-volume.yaml
Après cela, un disque sera automatiquement créé dans votre projet qui sera connecté à l'un des nœuds sbires du cluster. Lorsqu'il tombe, le disque bascule automatiquement vers un autre nœud.
Nous pouvons voir le disque à l'intérieur du conteneur avec Nginx:
$ kubectl exec -it nginx sh mount | grep "/var/www/html" /dev/sdc on /var/www/html type ext4 (rw,seclabel,relatime,data=ordered) exit
Vous pouvez connecter le lecteur au déploiement. Un exemple correspondant peut être trouvé dans la documentation officielle .
Panneau de configuration Kubernetes
Vous pouvez utiliser le tableau de bord intégré de Kubernetes lui-même pour afficher l'état des objets de cluster et leur gestion.
Pour accéder à toutes les fonctionnalités du panneau, vous devrez créer un compte avec le rôle d'administrateur dans votre cluster.
Pour ce faire, nous avons besoin d'une description de compte:
Et description du rĂ´le:
Créez les objets spécifiés:
$ kubectl create \ -f https://raw.githubusercontent.com/selectel/kubernetes-examples/master/accounts/admin-user.yaml \ -f https://raw.githubusercontent.com/selectel/kubernetes-examples/master/clusterrolebindings/cluster-admin.yaml
Ensuite, vous devrez découvrir la valeur du jeton généré pour ce compte.
Pour ce faire, recherchez l'objet Secret correspondant dans le cluster:
$ kubectl get secret --namespace=kube-system | grep "admin-user-token" admin-user-token-bkfhb kubernetes.io/service-account-token 3 22m
Et regardez la valeur du jeton du secret trouvé avec le nom admin-user-token-bkfhb:
$ kubectl describe secret admin-user-token-bkfhb --namespace=kube-system | grep "token:" token: XXXXXX...
En réponse, vous recevrez la valeur du jeton, enregistrez-la, elle nous sera utile à l'avenir.
Pour plus de détails sur le contrôle d'accès pour les objets Kubernetes, consultez la documentation officielle .
Dans le cas où vous avez créé un cluster à partir d'un modèle public, le pod et le service existent déjà pour garantir le fonctionnement du panneau:
$ kubectl get svc kubernetes-dashboard --namespace=kube-system 206ms Tue Jun 19 14:35:19 2018 NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE kubernetes-dashboard ClusterIP 10.254.122.245 <none> 443/TCP 2d $ kubectl get pod --namespace=kube-system --selector k8s-app=kubernetes-dashboard 119ms Tue Jun 19 14:36:48 2018 NAME READY STATUS RESTARTS AGE kubernetes-dashboard-747575c864-jpxvt 1/1 Running 0 2d
Étant donné que Service est de type ClusterIP, il ne sera disponible qu'à partir du cluster lui-même.
Vous pouvez accéder au panneau depuis votre ordinateur de travail avec le fichier de configuration du cluster à l'aide de la commande kubectl:
$ kubectl proxy Starting to serve on 127.0.0.1:8001
Testez le proxy en ouvrant l'adresse spécifiée dans le navigateur:
Si vous voyez une réponse similaire à la capture d'écran, vous pouvez accéder à l'écran du panneau de configuration en utilisant l'adresse suivante:
http://127.0.0.1:8001/api/v1/namespaces/kube-system/services/https:kubernetes-dashboard:/proxy/
En le parcourant, vous devriez voir l'Ă©cran de connexion dans le panneau:
Vous devrez spécifier le jeton reçu plus tôt. Une fois connecté, vous pouvez utiliser le panneau de configuration:
Vous pouvez découvrir toutes les fonctionnalités du panneau de contrôle dans la documentation officielle .
Surveillance des objets Kubernetes
Si vous utilisez le modèle de cluster public, vous exécuterez automatiquement les composants de collecte et d'affichage des métriques - Prometheus et Grafana.
De même que le panneau de configuration, ClusterIP est installé en tant que type de service; l'accès à celui-ci n'est possible que depuis le cluster ou via le proxy kubectl. Vous pouvez accéder à Grafana depuis votre ordinateur professionnel à l'adresse suivante:
http://127.0.0.1:8001/api/v1/proxy/namespaces/kube-system/services/monitoring-grafana:80
Conclusion
Dans cet article, nous avons examiné les objets Kubernetes les plus couramment utilisés et examiné des exemples de démarrage et de gestion d'un cluster à l'aide d'OpenStack Magnum.
Dans un avenir proche, il sera possible d'utiliser les dernières versions de Kubernetes et la gestion des clusters sera disponible via le panneau de configuration .
Nous serons heureux si vous utilisez notre service en mode test et fournissez des commentaires.