Ich habe Kubernetes, die in zwei verschiedenen Umgebungen gut funktionieren, nämlich in meiner lokalen Umgebung (MacBook mit Minikube) und in Googles Container Engine (GCE, Kubernetes in Google Cloud). Ich verwende das MacBook / die lokale Umgebung, um meine YAML-Dateien zu entwickeln und zu testen, und probiere sie nach Abschluss auf GCE aus.

Derzeit muss ich mit jeder Umgebung einzeln arbeiten: Ich muss die YAML-Dateien in meiner lokalen Umgebung bearbeiten und sie (git) in eine GCE-Umgebung klonen und sie dann verwenden / bereitstellen. Dies ist ein etwas umständlicher Prozess.

Idealerweise möchte ich kubectl von meinem Macbook verwenden, um einfach zwischen den lokalen Minikube- oder GCE Kubernetes-Umgebungen zu wechseln und einfach zu bestimmen, wo die YAML-Dateien verwendet werden. Gibt es eine einfache Möglichkeit, den Kontext zu wechseln, um dies zu tun?

Sie können von local (minikube) zu gcloud und zurück wechseln mit:

kubectl config use-context CONTEXT_NAME

um alle Kontexte aufzulisten:

kubectl config get-contexts

Sie können verschiedene Umgebungen für local und gcloud erstellen und in separaten yaml-Dateien ablegen.

Eine schnellere Verknüpfung zu den Standardbefehlen von kubectl ist die Verwendung von kubectx :

• Listenkontexte: kubectx
  • Gleichwertig kubectl config get-contexts
• Kontext wechseln (zu foo): kubectx foo
  • Gleichwertig kubectl config use-context foo

So installieren Sie unter macOS: brew install kubectx

Das kubectx-Paket enthält auch ein ähnliches Tool zum Wechseln von Namespaces kubens.

Diese beiden sind sehr praktisch, wenn Sie regelmäßig in mehreren Kontexten und Namespaces arbeiten.

Weitere Informationen: https://ahmet.im/blog/kubectx/

Wenn Sie nach einer GUI-basierten Lösung für Mac suchen und Docker Desktop installiert haben, können Sie das Symbol der Docker-Menüleiste verwenden. Hier finden Sie das Menü "Kubernetes" mit allen Kontexten, die Sie in Ihrer kubeconfig haben, und können einfach zwischen ihnen wechseln.

TL; DR: Ich habe eine GUI erstellt, um Kubernetes-Kontexte über AppleScript zu wechseln. Ich aktiviere es über shift-cmd-x.

Ich hatte auch das gleiche Problem. Es war ein schmerzverändernder Kontext über die Kommandozeile. Ich habe FastScripts verwendet, um eine Tastenkombination (shift-cmd-x) festzulegen, mit der das folgende AppleScript ausgeführt werden soll (in diesem Verzeichnis abgelegt: $ (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

Es wurde mir langweilig, dies immer und immer wieder zu tippen, also schrieb ich ein einfaches Bash-Dienstprogramm, um den Kontext zu wechseln

Sie finden es hier https://github.com/josefkorbel/kube-switch

Die neueste Antwort für 2020 ist hier,

Ein einfacher Weg, um zwischen kubectl Kontext zu wechseln,

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

kubectl top nodes --context=context02name

Sie können den Kontextnamen auch als env wie context01name = gke _ $ {GOOGLE_CLOUD_PROJECT} _us-central1-a_standard-cluster-1 speichern

Das Klonen der YAML-Dateien über Repos für verschiedene Umgebungen ist auf jeden Fall ideal. Sie müssen Ihre YAML-Dateien mit Vorlagen versehen, indem Sie die Parameter extrahieren, die sich von Umgebung zu Umgebung unterscheiden.

Sie können natürlich eine Template-Engine verwenden und die Werte in einer YAML trennen und die YAML für eine bestimmte Umgebung erstellen. Aber das ist leicht machbar , wenn Sie die nehmen Helm Charts . Um einige Beispieldiagramme anzusehen, gehen Sie zu einem stabilen Verzeichnis in diesem Github-Repo

Um ein Beispiel für das Wordpress-Diagramm zu nennen , können Sie zwei verschiedene Befehle für zwei Umgebungen verwenden:

Für Entwickler:

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

Es ist jedoch nicht erforderlich, diese Werte an die CLI zu übergeben. Sie können die Werte in einer Datei mit dem Namen treffend speichern values.ymlund möglicherweise unterschiedliche Dateien für unterschiedliche Umgebungen verwenden

Bei der Konvertierung in Helm-Diagrammstandards müssen Sie einige Arbeiten ausführen, aber der Aufwand lohnt sich.

Die kanonische Antwort des Umschaltens / Lesens / Manipulierens verschiedener Kubernetes-Umgebungen (auch bekannt als Kubernetes-Kontexte) lautet, wie Mark erwähnte, wie folgt kubectl config:

$ 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]

Hinter den Kulissen befindet sich eine ~/.kube/configYAML-Datei, in der alle verfügbaren Kontexte mit den entsprechenden Anmeldeinformationen und Endpunkten für jeden Kontext gespeichert sind.

Kubectl von der Stange macht es nicht einfach, verschiedene Kubernetes-Kontexte zu verwalten, wie Sie wahrscheinlich bereits wissen. Anstatt ein eigenes Skript zu kubectxerstellen , um all das zu verwalten, ist es besser, ein ausgereiftes Tool namens "Ahmet Alp Balkan" zu verwenden , das von einem Entwickler von Kubernetes / Google Cloud Platform entwickelt wurde. Ich empfehle es sehr.

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

Überprüfen Sie auch den neuesten docker contextBefehl (Docker 19.03) .

Ajeet Singh Raina ) illustriert es in " Docker 19.03.0 Pre-Release: Schnelle Kontextumschaltung, Rootless Docker, Sysctl-Unterstützung für Swarm Services ".

Ein Kontext ist im Wesentlichen die Konfiguration, mit der Sie auf einen bestimmten Cluster zugreifen.

Angenommen, in meinem speziellen Fall habe ich 4 verschiedene Cluster - eine Mischung aus Swarm und Kubernetes, die lokal und remote ausgeführt werden.
Angenommen, auf meinem Desktop-Computer wird ein Standardcluster ausgeführt, auf der Google Cloud Platform ein 2-Knoten-Schwarmcluster, auf dem Play with Docker-Spielplatz ein 5-Knoten-Cluster und auf Minikube ein Kubernetes-Cluster mit einem Knoten, auf den ich ziemlich zugreifen muss regelmäßig.

Mit der Docker-Kontext-CLI kann ich problemlos innerhalb von Sekunden von einem Cluster (der mein Entwicklungscluster sein kann) zum Test zum Produktionscluster wechseln.

$ 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.

Beispielsweise:

[:)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 

Falls Sie nach einer einfachen Möglichkeit suchen, zwischen verschiedenen Kontexten zu wechseln, ist dies möglicherweise hilfreich.

Ich habe inspiriert von kubectxund kswitchSkripten bereits erwähnt, die ich für die meisten Anwendungsfälle empfehlen. Sie helfen bei der Lösung der Schaltaufgabe, brechen aber für mich bei einigen größeren oder weniger Standardkonfigurationen von ~/.kube/config. Also habe ich einen Sys-Exec-Aufruf-Wrapper und eine Kurzanleitung erstellt kubectl.

Wenn Sie k ohne Parameter aufrufen, wird eine abgefangene Eingabeaufforderung zum Wechseln des Kontexts angezeigt.

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]:

Darüber hinaus fungiert kweiterhin als Short-Hand. Folgendes ist äquivalent:

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

Listen Sie Kontexte auf

kubectl config get-contexts

Wechseln Sie den Kontext

kubectl config set current-contex MY-CONTEXT

Um den gesamten Kontext zu erhalten

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

Um den aktuellen Kontext zu erhalten

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

Kontext wechseln

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

Ja, ich denke, das ist es, worüber du fragst. Verwenden Sie die kubectl-Konfigurationsansicht, um Ihre aktuelle Konfiguration anzuzeigen. kubectl lädt und führt config von den folgenden Speicherorten zusammen (in der Reihenfolge)

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

Ich benutze --kubeconfig, da ich viel zwischen mehreren Clustern wechsle. Es ist etwas umständlich, aber es funktioniert gut.

Weitere Informationen finden Sie in diesen. https://kubernetes.io/docs/tasks/administer-cluster/share-configuration/ und https://kubernetes.io/docs/concepts/cluster-administration/authenticate-across-clusters-kubeconfig/