Kubernetes fonctionne bien dans deux environnements différents, à savoir dans mon environnement local (MacBook exécutant minikube) et ainsi que sur Container Engine de Google (GCE, Kubernetes sur Google Cloud). J'utilise l'environnement MacBook / local pour développer et tester mes fichiers YAML, puis, une fois terminé, les essayer sur GCE.

Actuellement, je dois travailler avec chaque environnement individuellement: je dois modifier les fichiers YAML dans mon environnement local et, lorsque vous êtes prêt, (git) les cloner dans un environnement GCE, puis les utiliser / les déployer. C'est un processus un peu lourd.

Idéalement, j'aimerais utiliser kubectl de mon Macbook pour basculer facilement entre les environnements minikube locaux ou GCE Kubernetes et pour déterminer facilement où les fichiers YAML sont utilisés. Existe-t-il un moyen simple de changer de contexte pour ce faire?

Vous pouvez passer de local (minikube) à gcloud et inversement avec:

kubectl config use-context CONTEXT_NAME

pour lister tous les contextes:

kubectl config get-contexts

Vous pouvez créer différents environnements pour local et gcloud et le placer dans des fichiers yaml séparés.

Un raccourci plus rapide vers les commandes kubectl standard consiste à utiliser kubectx :

• Répertorier les contextes: kubectx
  • Équivalent à kubectl config get-contexts
• Changer de contexte (en foo): kubectx foo
  • Équivalent à kubectl config use-context foo

Pour installer sur macOS: brew install kubectx

Le package kubectx comprend également un outil similaire pour changer les espaces de noms appelé kubens.

Ces deux éléments sont très pratiques si vous travaillez régulièrement dans plusieurs contextes et espaces de noms.

Plus d'infos: https://ahmet.im/blog/kubectx/

Si vous recherchez une solution basée sur l'interface graphique pour Mac et que Docker Desktop est installé, vous pouvez utiliser l'icône de la barre de menus Docker. Ici vous pouvez trouver le menu "Kubernetes" avec tous les contextes que vous avez dans votre kubeconfig et basculer facilement entre eux.

La dernière réponse 2020 est ici,

Un moyen simple de basculer entre le contexte kubectl,

kubectl top nodes **--context=**context01name

kubectl top nodes --context=context02name

Vous pouvez également stocker le nom du contexte sous la forme env comme context01name = gke _ $ {GOOGLE_CLOUD_PROJECT} _us-central1-a_standard-cluster-1

TL; DR: J'ai créé une interface graphique pour changer les contextes Kubernetes via AppleScript. Je l'active via shift-cmd-x.

J'ai aussi eu le même problème. C'était une douleur de changement de contexte par la ligne de commande. J'ai utilisé FastScripts pour définir une combinaison de touches (shift-cmd-x) pour exécuter l'AppleScript suivant (placé dans ce répertoire: $ (HOME) / Library / Scripts / Applications / Terminal).

use AppleScript version "2.4" -- Yosemite (10.10) or later
use scripting additions

do shell script "/usr/local/bin/kubectl config current-context"
set curcontext to result

do shell script "/usr/local/bin/kubectl config get-contexts -o name"
set contexts to paragraphs of result

choose from list contexts with prompt "Select Context:" with title "K8s Context Selector" default items {curcontext}
set scriptArguments to item 1 of result

do shell script "/usr/local/bin/kubectl config use-context " & scriptArguments

display dialog "Switched to " & scriptArguments buttons {"ok"} default button 1

Je me suis ennuyé de taper ceci encore et encore, alors j'ai écrit un simple utilitaire bash pour changer de contexte

Vous pouvez le trouver ici https://github.com/josefkorbel/kube-switch

Le clonage des fichiers YAML sur des dépôts pour différents environnements est définitivement idéal. Ce que vous devez faire est de modéliser vos fichiers YAML - en extrayant les paramètres qui diffèrent d'un environnement à l'autre.

Vous pouvez, bien sûr, utiliser un moteur de création de modèles et séparer les valeurs dans un YAML et produire le YAML pour un environnement spécifique. Mais c'est facilement faisable si vous adoptez les graphiques de barre . Pour jeter un œil à quelques exemples de graphiques, accédez au répertoire stable de ce dépôt Github

Pour prendre un exemple du graphique Wordpress , vous pouvez avoir deux commandes différentes pour deux environnements:

Pour Dev:

helm install --name dev-release --set \ wordpressUsername=dev_admin, \ wordpressPassword=dev_password, \ mariadb.mariadbRootPassword=dev_secretpassword \ stable/wordpress

Cependant, il n'est pas nécessaire de transmettre ces valeurs à la CLI, vous pouvez stocker les valeurs dans un fichier appelé correctement values.ymlet vous pouvez avoir différents fichiers pour différents environnements

Vous aurez besoin d'un peu de travail pour vous convertir aux standards des graphiques Helm, mais l'effort en vaudra la peine.

La réponse canonique de la commutation / lecture / manipulation de différents environnements kubernetes (aka contextes kubernetes) est, comme Mark l'a mentionné, à utiliser kubectl config, voir ci-dessous:

$ kubectl config                                                                                                                                                                                                                 
Modify kubeconfig files using subcommands like "kubectl config set current-context my-context"

Available Commands:
  current-context Displays the current-context
  delete-cluster  Delete the specified cluster from the kubeconfig
  delete-context  Delete the specified context from the kubeconfig
  get-clusters    Display clusters defined in the kubeconfig
  get-contexts    Describe one or many contexts
  rename-context  Renames a context from the kubeconfig file.
  set             Sets an individual value in a kubeconfig file
  set-cluster     Sets a cluster entry in kubeconfig
  set-context     Sets a context entry in kubeconfig
  set-credentials Sets a user entry in kubeconfig
  unset           Unsets an individual value in a kubeconfig file
  use-context     Sets the current-context in a kubeconfig file
  view            Display merged kubeconfig settings or a specified kubeconfig file

Usage:
  kubectl config SUBCOMMAND [options]

Derrière la scène, il y a un ~/.kube/configfichier YAML qui stocke tous les contextes disponibles avec leurs informations d'identification et points de terminaison correspondants pour chaque contexte.

Kubectl prêt à l'emploi ne facilite pas la gestion de différents contextes Kubernetes comme vous le savez probablement déjà. Plutôt que de lancer votre propre script pour gérer tout cela, une meilleure approche consiste à utiliser un outil mature appelé kubectx, créé par un Googler nommé "Ahmet Alp Balkan" qui utilise des expériences de développement Kubernetes / Google Cloud Platform. Équipe qui construit des outils comme celui-ci. Je le recommande fortement.

https://github.com/ahmetb/kubectx

$ kctx --help                                                                                                                                                                                                                  
USAGE:
  kubectx                       : list the contexts
  kubectx <NAME>                : switch to context <NAME>
  kubectx -                     : switch to the previous context
  kubectx <NEW_NAME>=<NAME>     : rename context <NAME> to <NEW_NAME>
  kubectx <NEW_NAME>=.          : rename current-context to <NEW_NAME>
  kubectx -d <NAME> [<NAME...>] : delete context <NAME> ('.' for current-context)
                                  (this command won't delete the user/cluster entry
                                  that is used by the context)

  kubectx -h,--help         : show this message

Vérifiez aussi la dernière (docker 19,03) docker contextcommande .

Ajeet Singh Raina ) l'illustre dans " Docker 19.03.0 Pre-Release: Fast Context Switching, Rootless Docker, Sysctl support for Swarm Services "

Un contexte est essentiellement la configuration que vous utilisez pour accéder à un cluster particulier.

Disons, par exemple, dans mon cas particulier, j'ai 4 clusters différents - mélange de Swarm et Kubernetes fonctionnant localement et à distance.
Supposons que j'ai un cluster par défaut en cours d'exécution sur ma machine de bureau, un cluster Swarm à 2 nœuds fonctionnant sur Google Cloud Platform, un cluster à 5 nœuds fonctionnant sur Play avec Docker Playground et un cluster Kubernetes à nœud unique s'exécutant sur Minikube et que je dois accéder à une jolie régulièrement.

En utilisant la CLI de contexte de docker, je peux facilement passer d'un cluster (qui pourrait être mon cluster de développement) pour tester au cluster de production en quelques secondes.

$ sudo docker context --help
Usage:  docker context COMMAND
Manage contexts
Commands:
  create      Create a context
  export      Export a context to a tar or kubeconfig file
  import      Import a context from a tar file
  inspect     Display detailed information on one or more contexts
  ls          List contexts
  rm          Remove one or more contexts
  update      Update a context
  use         Set the current docker context
Run 'docker context COMMAND --help' for more information on a command.

Par exemple:

[:)Captain'sBay=>sudo docker context ls
NAME                DESCRIPTION                               DOCKER ENDPOINT               KUBERNETES ENDPOINT                 ORCHESTRATOR
default *           Current DOCKER_HOST based configuration   unix:///var/run/docker.sock   https://127.0.0.1:16443 (default)   swarm
swarm-context1 

Si vous cherchez un moyen simple de basculer entre différents contextes, cela vous sera peut-être utile.

Je me suis inspiré par kubectxet kswitchscripts déjà mentionné, que je recommande pour la plupart des cas d' utilisation. Ils aident à résoudre la tâche de commutation, mais se cassent pour moi sur certaines configurations plus grandes ou moins standard de ~/.kube/config. J'ai donc créé un wrapper d'invocation sys-exec et un raccourci kubectl.

Si vous appelez k sans paramètres, vous verrez une invite interceptée pour changer de contexte.

Switch kubectl to a different context/cluster/namespace.
Found following options to select from:
 >>> context: [1] franz
 >>> context: [2] gke_foo_us-central1-a_live-v1
 >>> context: [3] minikube
 --> new num [?/q]:

En outre, kcontinue d'agir comme un raccourci. Ce qui suit est équivalent:

kubectl get pods --all-namespaces
k get pods -A
k p -A

Répertorier les contextes

kubectl config get-contexts

Changer de contexte

kubectl config set current-contex MY-CONTEXT

Pour obtenir tout le contexte

C:\Users\arun>kubectl config get-contexts

Pour obtenir le contexte actuel

C:\Users\arun>kubectl config current-context

Pour changer de contexte

C:\Users\arun>kubectl config use-context <any context name from above list>

oui, je pense que c'est ce que vous demandez. Pour afficher votre configuration actuelle, utilisez la vue de configuration kubectl. kubectl charge et fusionne la configuration à partir des emplacements suivants (dans l'ordre)

--kubeconfig=/path/to/.kube/config command line flag
KUBECONFIG=/path/to/.kube/config env variable
$HOME/.kube/config  - The DEFAULT

J'utilise --kubeconfig depuis que je change beaucoup entre plusieurs clusters. c'est un peu encombrant mais ça marche bien.

consultez-les pour plus d'informations. https://kubernetes.io/docs/tasks/administer-cluster/share-configuration/ et https://kubernetes.io/docs/concepts/cluster-administration/authenticate-across-clusters-kubeconfig/