Tengo Kubernetes funcionando bien en dos entornos diferentes, a saber, en mi entorno local (MacBook con minikube) y también en Container Engine de Google (GCE, Kubernetes en Google Cloud). Utilizo el entorno MacBook / local para desarrollar y probar mis archivos YAML y luego, al finalizar, los pruebo en GCE.

Actualmente necesito trabajar con cada entorno individualmente: necesito editar los archivos YAML en mi entorno local y, cuando esté listo, (git) clonarlos en un entorno GCE y luego usarlos / implementarlos. Este es un proceso algo engorroso.

Idealmente, me gustaría usar kubectl desde mi Macbook para cambiar fácilmente entre los entornos locales de minikube o GCE Kubernetes y determinar fácilmente dónde se usan los archivos YAML. ¿Existe una forma sencilla de cambiar de contexto para hacer esto?

Puedes cambiar de local (minikube) a gcloud y viceversa con:

kubectl config use-context CONTEXT_NAME

para enumerar todos los contextos:

kubectl config get-contexts

Puede crear diferentes entornos para local y gcloud y colocarlos en archivos yaml separados.

Un atajo más rápido a los comandos estándar de kubectl es usar kubectx :

• Lista de contextos: kubectx
  • Equivalente a kubectl config get-contexts
• Cambiar contexto (a foo): kubectx foo
  • Equivalente a kubectl config use-context foo

Para instalar en macOS: brew install kubectx

El paquete kubectx también incluye una herramienta similar para cambiar los espacios de nombres llamada kubens.

Estos dos son muy convenientes si trabaja en múltiples contextos y espacios de nombres con regularidad.

Más información: https://ahmet.im/blog/kubectx/

Si está buscando una solución basada en GUI para Mac y tiene instalado Docker Desktop, puede usar el icono de la barra de menú de Docker. Aquí puede encontrar el menú "Kubernetes" con todos los contextos que tiene en su kubeconfig y cambiar fácilmente entre ellos.

La última respuesta de 2020 está aquí,

Una forma sencilla de cambiar entre el contexto de kubectl,

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

kubectl top nodes --context=context02name

También puede almacenar el nombre del contexto como env como context01name = gke _ $ {GOOGLE_CLOUD_PROJECT} _us-central1-a_standard-cluster-1

TL; DR: Creé una GUI para cambiar los contextos de Kubernetes a través de AppleScript. Lo activo a través de shift-cmd-x.

Yo también tuve el mismo problema. Fue un dolor cambiar contextos por la línea de comando. Usé FastScripts para configurar una combinación de teclas (shift-cmd-x) para ejecutar el siguiente AppleScript (ubicado en este directorio: $ (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

Me aburrí de escribir esto una y otra vez, así que escribí una utilidad bash simple para cambiar de contexto

Puedes encontrarlo aquí https://github.com/josefkorbel/kube-switch

La clonación de archivos YAML en repositorios para diferentes entornos es definitivamente ideal. Lo que debe hacer es crear plantillas para sus archivos YAML, extrayendo los parámetros que difieren de un entorno a otro.

Por supuesto, puede usar algún motor de plantillas y separar los valores en un YAML y producir el YAML para un entorno específico. Pero esto es fácil de hacer si adoptas los Helm Charts . Para echar un vistazo a algunos gráficos de muestra, vaya al directorio estable en este repositorio de Github

Para tomar un ejemplo del gráfico de Wordpress , podría tener dos comandos diferentes para dos entornos:

Para Dev:

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

Sin embargo, no es necesario pasar estos valores en la CLI, puede almacenar los valores en un archivo llamado adecuadamente values.ymly podría tener diferentes archivos para diferentes entornos

Necesitará algo de trabajo para realizar la conversión a los estándares de gráficos de Helm, pero el esfuerzo valdrá la pena.

La respuesta canónica de cambiar / leer / manipular diferentes entornos de kubernetes (también conocidos como contextos de kubernetes) es, como mencionó Mark, usar kubectl config , vea a continuación:

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

Detrás de la escena, hay un ~/.kube/configarchivo YAML que almacena todos los contextos disponibles con sus correspondientes credenciales y puntos finales para cada contexto.

Kubectl listo para usar no facilita la administración de diferentes contextos de kubernetes como probablemente ya sepa. En lugar de ejecutar su propio script para gestionar todo eso, un mejor enfoque es utilizar una herramienta madura llamadakubectx , creada por un empleado de Google llamado "Ahmet Alp Balkan", que está en el equipo de experiencias de desarrollador de Kubernetes / Google Cloud Platform que crea herramientas como esta. Lo recomiendo altamente.

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

Compruebe también el último comando (docker 19.03)docker context .

Ajeet Singh Raina ) lo ilustra en " Pre-lanzamiento de Docker 19.03.0: Cambio de contexto rápido, Docker sin raíz, soporte Sysctl para Swarm Services "

Un contexto es esencialmente la configuración que usa para acceder a un clúster en particular.

Digamos, por ejemplo, en mi caso particular, tengo 4 clústeres diferentes: una combinación de Swarm y Kubernetes que se ejecutan de forma local y remota.
Supongamos que tengo un clúster predeterminado que se ejecuta en mi máquina de escritorio, un clúster Swarm de 2 nodos que se ejecuta en Google Cloud Platform, un clúster de 5 nodos que se ejecuta en Play with Docker playground y un clúster de Kubernetes de un solo nodo que se ejecuta en Minikube y que necesito acceder bastante regularmente.

Al usar la CLI de contexto de Docker, puedo cambiar fácilmente de un clúster (que podría ser mi clúster de desarrollo) para probar al clúster de producción en segundos.

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

Por ejemplo:

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

En caso de que esté buscando una forma sencilla de cambiar entre diferentes contextos, tal vez esto sea de ayuda.

Me inspiré kubectxy kswitchguiones ya se ha mencionado, que puedo recomendar para la mayoría de los casos de uso. Están ayudando a resolver la tarea de conmutación, pero me están rompiendo en algunas configuraciones más grandes o menos estándar de ~/.kube/config. Así que creé un contenedor de invocación sys-exec y un resumen kubectl.

Si llama a k sin parámetros, verá un mensaje interceptado para cambiar de contexto.

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

Además, ksigue actuando como un atajo. Lo siguiente es equivalente:

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

Lista de contextos

kubectl config get-contexts

Cambiar contextos

kubectl config set current-contex MY-CONTEXT

Para obtener todo el contexto

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

Para obtener el contexto actual

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

Para cambiar de contexto

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

sí, creo que esto es sobre lo que preguntas. Para ver su configuración actual, use la vista de configuración de kubectl. kubectl carga y fusiona la configuración de las siguientes ubicaciones (en orden)

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

Yo uso --kubeconfig ya que cambio mucho entre múltiples clústeres. es un poco engorroso pero funciona bien.

consulte estos para obtener más información. https://kubernetes.io/docs/tasks/administer-cluster/share-configuration/ y https://kubernetes.io/docs/concepts/cluster-administration/authenticate-across-clusters-kubeconfig/