nodeselector - kubernetes describe pod

¿Cómo agregar usuarios a Kubernetes(kubectl)?

Question

Creé un clúster de Kubernetes en AWS con kops y puedo administrarlo con éxito a través de kubectl desde mi máquina local.

Puedo ver la configuración actual con la kubectl config view , así como acceder directamente al estado almacenado en ~/.kube/config , como:

apiVersion: v1
clusters:
- cluster:
certificate-authority-data: REDACTED
server: https://api.{CLUSTER_NAME}
name: {CLUSTER_NAME}
contexts:
- context:
cluster: {CLUSTER_NAME}
user: {CLUSTER_NAME}
name: {CLUSTER_NAME}
current-context: {CLUSTER_NAME}
kind: Config
preferences: {}
users:
- name: {CLUSTER_NAME}
user:
client-certificate-data: REDACTED
client-key-data: REDACTED
password: REDACTED
username: admin
- name: {CLUSTER_NAME}-basic-auth
user:
password: REDACTED
username: admin

Necesito permitir que otros usuarios también administren. Esta guía del usuario describe cómo definirlos en la máquina de otro usuario, pero no describe cómo crear realmente las credenciales del usuario dentro del clúster. ¿Cómo haces esto?

Además, ¿es seguro simplemente compartir el cluster.certificate-authority-data ?

Answer 1

La guía bitnami funciona para mí, incluso si usas minikube. Lo más importante es que su clúster admite RBAC. https://docs.bitnami.com/kubernetes/how-to/configure-rbac-in-your-kubernetes-cluster/

Answer 2

Para obtener una descripción general completa de la autenticación, consulte los documentos oficiales de Kubernetes sobre Authentication y Authorization

Para los usuarios, lo ideal es utilizar un proveedor de identidad para Kubernetes (OpenID Connect).

Si está en GKE / ACS, se integra con los respectivos marcos de gestión de identidad y acceso

Si autohospeda kubernetes (que es el caso cuando usa kops), puede usar coreos/dex para integrarse con proveedores de identidad LDAP / OAuth2; una buena referencia es este detallado SSO de 2 partes para el artículo de Kubernetes .

kops (1.10+) ahora tiene soporte de autenticación incorporado que facilita la integración con AWS IAM como proveedor de identidad si está en AWS.

para Dex hay algunos clientes cli de código abierto de la siguiente manera:

• Nordstrom/kubelogin
• pusher/k8s-auth-example

Si está buscando una manera rápida y fácil de comenzar (no la más segura y fácil de administrar a largo plazo), puede abusar de las serviceaccounts , con 2 opciones de Políticas especializadas para controlar el acceso. (vea abajo)

¡NOTA ya que se recomienda el control de acceso basado en roles 1.6! esta respuesta no cubre la configuración de RBAC

EDITAR : También está disponible una gran guía de Bitnami sobre la configuración del usuario con RBAC .

Los pasos para habilitar el acceso a la cuenta de servicio son (dependiendo de si la configuración de su clúster incluye políticas RBAC o ABAC, estas cuentas pueden tener derechos de administrador completos):

EDITAR : aquí hay un script bash para automatizar la creación de la cuenta de servicio; consulte los pasos a continuación

1. Crear cuenta de servicio para el usuario Alice

   kubectl create sa alice

2. Obtener secreto relacionado

   secret=$(kubectl get sa alice -o json | jq -r .secrets[].name)

3. Obtenga ca.crt del secreto (usando OSX base64 con el indicador -D para la decodificación)

   kubectl get secret $secret -o json | jq -r ''.data["ca.crt"]'' | base64 -D > ca.crt

4. Obtener token de cuenta de servicio de secreto

   user_token=$(kubectl get secret $secret -o json | jq -r ''.data["token"]'' | base64 -D)

5. Obtenga información de su configuración de kubectl (current-context, server ..)

   # get current context
   c=`kubectl config current-context`
   # get cluster name of context
   name=`kubectl config get-contexts $c | awk ''{print $3}'' | tail -n 1`
   # get endpoint of current context
   endpoint=`kubectl config view -o jsonpath="{.clusters[?(@.name == /"$name/")].cluster.server}"`

6. En una máquina nueva, siga estos pasos (dada la información de ca.cert y $endpoint recuperada anteriormente:

   1. Instalar kubectl

      brew install kubectl

   2. Establecer clúster (ejecutar en el directorio donde se almacena ca.crt )

      kubectl config set-cluster cluster-staging /
      --embed-certs=true /
      --server=$endpoint /
      --certificate-authority=./ca.crt

   3. Establecer credenciales de usuario

      kubectl config set-credentials alice-staging --token=$user_token

   4. Defina la combinación de alice user con el clúster de etapas

      kubectl config set-context alice-staging /
      --cluster=cluster-staging /
      --user=alice-staging /
      --namespace=alice

   5. Cambie el contexto actual a alice-staging para el usuario

      kubectl config use-context alice-staging

Para controlar el acceso de los usuarios con políticas (mediante ABAC ), debe crear un archivo de Authentication (por ejemplo):

{
"apiVersion": "abac.authorization.kubernetes.io/v1beta1",
"kind": "Policy",
"spec": {
"user": "system:serviceaccount:default:alice",
"namespace": "default",
"resource": "*",
"readonly": true
}
}

Aprovisione este policy.json en cada nodo maestro y agregue --authorization-mode=ABAC --authorization-policy-file=/path/to/policy.json flags a los servidores API

Esto permitiría a Alice (a través de su cuenta de servicio) derechos de solo lectura para todos los recursos en el espacio de nombres predeterminado solamente.

Answer 3

Tu dices :

Necesito permitir que otros usuarios también administren.

Pero de acuerdo con la documentation

Se supone que los usuarios normales son administrados por un servicio externo e independiente. Un administrador que distribuye claves privadas, una tienda de usuarios como Keystone o Cuentas de Google, incluso un archivo con una lista de nombres de usuario y contraseñas. A este respecto, Kubernetes no tiene objetos que representen cuentas de usuario normales. Los usuarios normales no se pueden agregar a un clúster a través de una llamada API.

Tienes que usar una herramienta de terceros para esto.

== Editar ==

Una solución podría ser crear manualmente una entrada de usuario en el archivo kubeconfig . De la documentación :

# create kubeconfig entry
$ kubectl config set-cluster $CLUSTER_NICK /
--server=https://1.1.1.1 /
--certificate-authority=/path/to/apiserver/ca_file /
--embed-certs=true /
# Or if tls not needed, replace --certificate-authority and --embed-certs with
--insecure-skip-tls-verify=true /
--kubeconfig=/path/to/standalone/.kube/config
# create user entry
$ kubectl config set-credentials $USER_NICK /
# bearer token credentials, generated on kube master
--token=$token /
# use either username|password or token, not both
--username=$username /
--password=$password /
--client-certificate=/path/to/crt_file /
--client-key=/path/to/key_file /
--embed-certs=true /
--kubeconfig=/path/to/standalone/.kube/config
# create context entry
$ kubectl config set-context $CONTEXT_NAME /
--cluster=$CLUSTER_NICK /
--user=$USER_NICK /
--kubeconfig=/path/to/standalone/.kube/config