Tenho o Kubernetes funcionando bem em dois ambientes diferentes, a saber, no meu ambiente local (MacBook executando minikube) e também no Container Engine do Google (GCE, Kubernetes no Google Cloud). Eu uso o MacBook / ambiente local para desenvolver e testar meus arquivos YAML e, após a conclusão, testá-los no GCE.

Atualmente, preciso trabalhar com cada ambiente individualmente: preciso editar os arquivos YAML em meu ambiente local e, quando estiver pronto, (git) cloná-los em um ambiente GCE e depois usá-los / implantá-los. Este é um processo um tanto complicado.

Idealmente, gostaria de usar kubectl do meu Macbook para alternar facilmente entre os ambientes minikube local ou GCE Kubernetes e determinar facilmente onde os arquivos YAML são usados. Existe uma maneira simples de alternar contextos para fazer isso?

Você pode alternar de local (minikube) para gcloud e vice-versa com:

kubectl config use-context CONTEXT_NAME

para listar todos os contextos:

kubectl config get-contexts

Você pode criar ambientes diferentes para local e gcloud e colocá-los em arquivos yaml separados.

Um atalho mais rápido para os comandos kubectl padrão é usar kubectx :

• Contextos da lista: kubectx
  • Equivalente a kubectl config get-contexts
• Mudar de contexto (para foo): kubectx foo
  • Equivalente a kubectl config use-context foo

Para instalar no macOS: brew install kubectx

O pacote kubectx também inclui uma ferramenta semelhante para alternar namespaces, chamada kubens.

Esses dois são muito convenientes se você trabalha em vários contextos e namespaces regularmente.

Mais informações: https://ahmet.im/blog/kubectx/

Se você está procurando uma solução baseada em GUI para Mac e tem o Docker Desktop instalado, pode usar o ícone Docker Menu Bar. Aqui você pode encontrar o menu "Kubernetes" com todos os contextos que possui em seu kubeconfig e alternar facilmente entre eles.

A última resposta de 2020 está aqui,

Uma maneira simples de alternar entre o contexto kubectl,

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

kubectl top nodes --context=context02name

Você também pode armazenar o nome do contexto como env, como context01name = gke _ $ {GOOGLE_CLOUD_PROJECT} _us-central1-a_standard-cluster-1

TL; DR: criei uma GUI para alternar os contextos do Kubernetes via AppleScript. Eu o ativo via shift-cmd-x.

Eu também tive o mesmo problema. Foi uma dor mudar de contexto pela linha de comando. Usei FastScripts para definir uma combinação de teclas (shift-cmd-x) para executar o seguinte AppleScript (localizado neste diretório: $ (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

Fiquei entediado de digitar isso sem parar, então escrevi um utilitário bash simples para alternar contextos

Você pode encontrá-lo aqui https://github.com/josefkorbel/kube-switch

A clonagem de arquivos YAML em repos para ambientes diferentes é definitivamente ideal. O que você deve fazer é modelar seus arquivos YAML - extraindo os parâmetros que diferem de ambiente para ambiente.

Você pode, é claro, usar algum mecanismo de modelagem e separar os valores em um YAML e produzir o YAML para um ambiente específico. Mas isso é facilmente viável se você adotar os gráficos do Helm . Para dar uma olhada em alguns gráficos de amostra, vá para o diretório estável neste repositório Github

Para dar um exemplo do gráfico Wordpress , você poderia ter dois comandos diferentes para dois ambientes:

Para Dev:

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

Não é necessário passar esses valores na CLI, você pode armazenar os valores em um arquivo chamado apropriadamente values.ymle você pode ter arquivos diferentes para ambientes diferentes

Você precisará trabalhar um pouco para se converter aos padrões da carta Helm, mas o esforço valerá a pena.

A resposta canônica de alternar / ler / manipular diferentes ambientes de kubernetes (também conhecidos como contextos de kubernetes) deve ser usada, como Mark mencionou kubectl config, veja abaixo:

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

Nos bastidores, há um ~/.kube/configarquivo YAML que armazena todos os contextos disponíveis com suas credenciais e endpoints correspondentes para cada contexto.

O Kubectl pronto para uso não facilita o gerenciamento de diferentes contextos de kubernetes, como você provavelmente já sabe. Em vez de lançar seu próprio script para gerenciar tudo isso, uma abordagem melhor é usar uma ferramenta madura chamada kubectx, criada por um Googler chamado "Ahmet Alp Balkan", que está na equipe de experiências de desenvolvedor do Kubernetes / Google Cloud Platform que cria ferramentas como esta. Eu recomendo.

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

Verifique também o docker contextcomando mais recente (docker 19.03) .

Ajeet Singh Raina ) ilustra isso em " Docker 19.03.0 Pre-Release: Fast Context Switching, Rootless Docker, Sysctl support for Swarm Services "

Um contexto é essencialmente a configuração que você usa para acessar um determinado cluster.

Digamos, por exemplo, no meu caso específico, que eu tenha 4 clusters diferentes - mistura de Swarm e Kubernetes em execução local e remota.
Suponha que eu tenha um cluster padrão em execução na minha máquina Desktop, Cluster Swarm de 2 nós em execução no Google Cloud Platform, Cluster de 5 nós em execução no Play with Docker playground e um cluster Kubernetes de nó único em execução no Minikube e que preciso acessar bastante regularmente.

Usando a CLI de contexto do docker, posso alternar facilmente de um cluster (que poderia ser meu cluster de desenvolvimento) para o cluster de teste para produção em 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 exemplo:

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

Caso você esteja procurando uma maneira simples de alternar entre diferentes contextos, talvez isso seja útil.

Eu fui inspirado por kubectxe kswitchroteiros já mencionado, o que eu posso recomendar para a maioria dos casos de uso. Eles estão ajudando a resolver a tarefa de comutação, mas estão quebrando para mim em algumas configurações maiores ou menos padrão de ~/.kube/config. Portanto, criei um wrapper de invocação sys-exec e um atalho kubectl.

Se você chamar k sem parâmetros, verá um prompt interceptado para alternar o 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]:

Além disso, kcontinua atuando como um atalho. O seguinte é equivalente:

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

Contextos de lista

kubectl config get-contexts

Mudar de contexto

kubectl config set current-contex MY-CONTEXT

Para obter todo o contexto

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

Para obter o contexto atual

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

Para mudar de contexto

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

sim, acho que é sobre isso que você está perguntando. Para visualizar sua configuração atual, use a visualização de configuração kubectl. O kubectl carrega e mescla a configuração dos seguintes locais (em ordem)

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

Eu uso --kubeconfig, pois alterno muito entre vários clusters. é um pouco complicado, mas funciona bem.

veja estes para mais informações. https://kubernetes.io/docs/tasks/administer-cluster/share-configuration/ e https://kubernetes.io/docs/concepts/cluster-administration/authenticate-across-clusters-kubeconfig/