kubernetes-sigs/aws-iam-authenticatorUno strumento per utilizzare le credenziali AWS IAM per autenticarsi a un cluster Kubernetes
Uno strumento per utilizzare le credenziali AWS IAM per autenticarsi su un cluster Kubernetes. Il lavoro iniziale su questo strumento è stato guidato da Heptio. Il progetto riceve contributi da diversi ingegneri della community ed è attualmente mantenuto da Heptio e dagli ingegneri OSS di Amazon EKS.
Se sei un amministratore che gestisce un cluster Kubernetes su AWS, devi già gestire le credenziali AWS IAM per il provisioning e l'aggiornamento del cluster. Utilizzando AWS IAM Authenticator for Kubernetes eviti di dover gestire una credenziale separata per l'accesso a Kubernetes. AWS IAM offre anche una serie di proprietà interessanti come una traccia di audit esterna (tramite CloudTrail) e l'applicazione di 2FA/MFA.
Se stai creando un installer Kubernetes su AWS, AWS IAM Authenticator for Kubernetes può semplificare il tuo processo di bootstrap.
Non dovrai introdurre di nascosto la tua credenziale admin iniziale in modo sicuro dal cluster appena installato.
Invece, puoi creare un ruolo dedicato KubernetesAdmin in fase di provisioning del cluster e configurare Authenticator per consentire gli accessi degli amministratori del cluster.
Supponendo che tu abbia un cluster in esecuzione su AWS e che tu voglia aggiungere il supporto per AWS IAM Authenticator for Kubernetes, devi:
Per prima cosa, devi creare uno o più ruoli IAM che verranno mappati a utenti/gruppi all'interno del tuo cluster Kubernetes. Il modo più semplice per farlo è accedere alla console AWS:
In questo modo verrà creato un ruolo IAM senza autorizzazioni che può essere assunto da utenti/ruoli autorizzati nel tuo account. Prendi nota dell'Amazon Resource Name (ARN) del tuo ruolo, che ti servirà in seguito.
Puoi anche farlo in un unico passaggio usando la AWS CLI invece della console AWS:```sh
ACCOUNT_ID=$(aws sts get-caller-identity --output text --query 'Account')
POLICY=$(echo -n '{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Principal":{"AWS":"arn:aws:iam::'; echo -n "$ACCOUNT_ID"; echo -n ':root"},"Action":"sts:AssumeRole","Condition":{}}]}')
aws iam create-role
--role-name KubernetesAdmin
--description "Kubernetes administrator role (for AWS IAM Authenticator for Kubernetes)."
--assume-role-policy-document "$POLICY"
--output text
--query 'Role.Arn'
Puoi anche saltare questo passaggio e usare:
- Un ruolo esistente (come un ruolo di accesso cross-account).
- Un utente IAM (vedi `mapUsers` sotto).
- Un'istanza EC2 o un ruolo federato (vedi `mapRoles` sotto).
### 2. Esegui il server
Il server è pensato per essere eseguito su ciascuno dei tuoi nodi master come DaemonSet con networking host, così da poter esporre una porta localhost.
Per una ConfigMap e una configurazione DaemonSet di esempio, vedi [`deploy/example.yaml`](https://github.com/kubernetes-sigs/aws-iam-authenticator/blob/master/deploy/example.yaml).
Prima di applicarla, aggiorna questi valori per il tuo cluster:
- Sostituisci gli ARN IAM segnaposto (`arn:aws:iam::000000000000:...`) in `config.yaml`.
- Imposta `clusterID` su un valore univoco per il tuo cluster.
- Verifica che le regole di pianificazione del DaemonSet corrispondano alle etichette/taint dei tuoi nodi del control plane.
Poi distribuiscilo:```sh
kubectl apply -f deploy/example.yaml
kubectl -n kube-system rollout status daemonset/aws-iam-authenticator
kubectl -n kube-system get pods -l k8s-app=aws-iam-authenticator
Una volta che il pod è in esecuzione su un nodo del piano di controllo, aws-iam-authenticator server creerà il kubeconfig del webhook sull'host nel percorso /etc/kubernetes/aws-iam-authenticator/kubeconfig.yaml (o nel percorso configurato tramite --generate-kubeconfig).
Se stai creando un programma di installazione automatizzato, puoi anche pre-generare facilmente i file del certificato, della chiave e del kubeconfig del webhook usando aws-iam-authenticator init.
Questo comando genererà i file e li collocherà nelle directory di output configurate.
Puoi eseguirlo su ogni nodo master prima di avviare il server API. Potresti anche generarli prima del provisioning dei nodi master e installarli nei percorsi host appropriati.
Se non pre-generi i file, aws-iam-authenticator server li genererà su richiesta.
Questa soluzione funziona, ma richiede di riavviare il server API di Kubernetes dopo l'installazione.
L'API di Kubernetes si integra con AWS IAM Authenticator for Kubernetes utilizzando un webhook di autenticazione token.
Quando esegui aws-iam-authenticator server, questo genererà un file di configurazione del webhook e lo salverà sul filesystem dell'host.
Dovrai aggiungere un unico flag aggiuntivo alla configurazione del tuo server API:```
--authentication-token-webhook-config-file=/etc/kubernetes/aws-iam-authenticator/kubeconfig.yaml
Su molti cluster, il server API viene eseguito come pod statico.
Puoi aggiungere il flag a `/etc/kubernetes/manifests/kube-apiserver.yaml`.
Assicurati che la directory host `/etc/kubernetes/aws-iam-authenticator/` sia montata nel pod del server API.
Potrebbe anche essere necessario riavviare il demone kubelet sul nodo master per applicare la definizione aggiornata del pod statico:```
systemctl restart kubelet.service
Il comportamento predefinito del server è quello di recuperare le mappature esclusivamente dai campi mapUsers e mapRoles del proprio file di configurazione. Vedi Formato Completo di Configurazione qui sotto per i dettagli.
Utilizzando il flag --backend-mode, puoi configurare il server per recuperare le mappature da due backend aggiuntivi: una ConfigMap in stile EKS (--backend-mode=EKSConfigMap) o risorse personalizzate IAMIdentityMapping (--backend-mode=CRD). Il backend predefinito, ovvero il file di configurazione del server montato dal pod del server, corrisponde a --backend-mode=MountedFile.