ProHoster > Blog > Uprava > Preverjanje pristnosti v Kubernetesu z uporabo GitHub OAuth in Dex

Preverjanje pristnosti v Kubernetesu z uporabo GitHub OAuth in Dex

Predstavljam vam vadnico za generiranje dostopa do gruče Kubernetes z uporabo Dex, dex-k8s-authenticator in GitHub.

Preverjanje pristnosti v Kubernetesu z uporabo GitHub OAuth in Dex
Lokalni meme iz klepeta Kubernetes v ruskem jeziku v Telegram

Predstavitev

Kubernetes uporabljamo za ustvarjanje dinamičnih okolij za razvojno in QA ekipo. Zato jim želimo omogočiti dostop do gruče za nadzorno ploščo in kubectl. Za razliko od OpenShift, vanilija Kubernetes nima izvorne avtentikacije, zato za to uporabljamo orodja tretjih oseb.

V tej konfiguraciji uporabljamo:

  • dex-k8s-avtentifikator  — spletna aplikacija za generiranje konfiguracije kubectl
  • Dex — Ponudnik OpenID Connect
  • GitHub – preprosto zato, ker uporabljamo GitHub v našem podjetju

Poskušali smo uporabiti Google OIDC, a žal smo neuspešno da jih začnemo s skupinami, zato nam je integracija z GitHubom zelo ustrezala. Brez preslikave skupin ne bo mogoče ustvariti pravilnikov RBAC na podlagi skupin.

Torej, kako deluje naš avtorizacijski postopek Kubernetes v vizualni predstavitvi:

Preverjanje pristnosti v Kubernetesu z uporabo GitHub OAuth in Dex
Postopek avtorizacije

Malo več podrobnosti in po točkah:

  1. Uporabnik se prijavi v dex-k8s-authenticator (login.k8s.example.com)
  2. dex-k8s-authenticator posreduje zahtevo Dexu (dex.k8s.example.com)
  3. Dex preusmeri na prijavno stran GitHub
  4. GitHub ustvari potrebne podatke za avtorizacijo in jih vrne Dexu
  5. Dex posreduje prejete informacije dex-k8s-authenticatorju
  6. Uporabnik prejme žeton OIDC od GitHub
  7. dex-k8s-authenticator doda žeton v kubeconfig
  8. kubectl posreduje žeton KubeAPIServerju
  9. KubeAPIServer vrne dostope do kubectl na podlagi posredovanega žetona
  10. Uporabnik dobi dostop iz kubectl

Pripravljalne dejavnosti

Seveda že imamo nameščeno gručo Kubernetes (k8s.example.com), prav tako pa ima vnaprej nameščen HELM. Imamo tudi organizacijo na GitHubu (super-org).
Če nimate HELM-a, ga namestite zelo enostavna.

Najprej moramo nastaviti GitHub.

Pojdite na stran z nastavitvami organizacije, (https://github.com/organizations/super-org/settings/applications) in ustvarite novo aplikacijo (Authorized OAuth App):
Preverjanje pristnosti v Kubernetesu z uporabo GitHub OAuth in Dex
Ustvarjanje nove aplikacije na GitHubu

Izpolnite polja s potrebnimi URL-ji, na primer:

  • URL domače strani: https://dex.k8s.example.com
  • URL povratnega klica avtorizacije: https://dex.k8s.example.com/callback

Bodite previdni pri povezavah, pomembno je, da ne izgubite poševnic.

Kot odgovor na izpolnjen obrazec bo GitHub ustvaril Client ID и Client secret, jih hranimo na varnem mestu, nam bodo koristile (npr. uporabljamo Vault za shranjevanje skrivnosti):

Client ID: 1ab2c3d4e5f6g7h8
Client secret: 98z76y54x32w1

Pripravite DNS zapise za poddomene login.k8s.example.com и dex.k8s.example.com, kot tudi SSL certifikate za vstop.

Ustvarimo SSL certifikate:

cat <<EOF | kubectl create -f -
apiVersion: certmanager.k8s.io/v1alpha1
kind: Certificate
metadata:
  name: cert-auth-dex
  namespace: kube-system
spec:
  secretName: cert-auth-dex
  dnsNames:
    - dex.k8s.example.com
  acme:
    config:
    - http01:
        ingressClass: nginx
      domains:
      - dex.k8s.example.com
  issuerRef:
    name: le-clusterissuer
    kind: ClusterIssuer
---
apiVersion: certmanager.k8s.io/v1alpha1
kind: Certificate
metadata:
  name: cert-auth-login
  namespace: kube-system
spec:
  secretName: cert-auth-login
  dnsNames:
    - login.k8s.example.com
  acme:
    config:
    - http01:
        ingressClass: nginx
      domains:
      - login.k8s.example.com
  issuerRef:
    name: le-clusterissuer
    kind: ClusterIssuer
EOF
kubectl describe certificates cert-auth-dex -n kube-system
kubectl describe certificates cert-auth-login -n kube-system

ClusterIssuer z naslovom le-clusterissuer že mora obstajati, če pa ne, ga ustvarite s HELM:

helm install --namespace kube-system -n cert-manager stable/cert-manager
cat << EOF | kubectl create -f -
apiVersion: certmanager.k8s.io/v1alpha1
kind: ClusterIssuer
metadata:
  name: le-clusterissuer
  namespace: kube-system
spec:
  acme:
    server: https://acme-v02.api.letsencrypt.org/directory
    email: [email protected]
    privateKeySecretRef:
      name: le-clusterissuer
    http01: {}
EOF

Konfiguracija KubeAPIServer

Da kubeAPIServer deluje, morate konfigurirati OIDC in posodobiti gručo:

kops edit cluster
...
  kubeAPIServer:
    anonymousAuth: false
    authorizationMode: RBAC
    oidcClientID: dex-k8s-authenticator
    oidcGroupsClaim: groups
    oidcIssuerURL: https://dex.k8s.example.com/
    oidcUsernameClaim: email
kops update cluster --yes
kops rolling-update cluster --yes

Uporabljamo brcati za uvajanje gruč, vendar to deluje podobno za drugi upravljavci grozdov.

Konfiguracija Dex in dex-k8s-avtentifikator

Da bo Dex deloval, morate imeti potrdilo in ključ od masterja Kubernetes, poglejmo od tam:

sudo cat /srv/kubernetes/ca.{crt,key}
-----BEGIN CERTIFICATE-----
AAAAAAAAAAABBBBBBBBBBCCCCCC
-----END CERTIFICATE-----
-----BEGIN RSA PRIVATE KEY-----
DDDDDDDDDDDEEEEEEEEEEFFFFFF
-----END RSA PRIVATE KEY-----

Klonirajmo repozitorij dex-k8s-authenticator:

git clone [email protected]:mintel/dex-k8s-authenticator.git
cd dex-k8s-authenticator/

Z uporabo datotek z vrednostmi lahko prilagodljivo konfiguriramo spremenljivke za naše karte HELM.

Opišimo konfiguracijo za Dex:

cat << EOF > values-dex.yml
global:
  deployEnv: prod
tls:
  certificate: |-
    -----BEGIN CERTIFICATE-----
    AAAAAAAAAAABBBBBBBBBBCCCCCC
    -----END CERTIFICATE-----
  key: |-
    -----BEGIN RSA PRIVATE KEY-----
    DDDDDDDDDDDEEEEEEEEEEFFFFFF
    -----END RSA PRIVATE KEY-----
ingress:
  enabled: true
  annotations:
    kubernetes.io/ingress.class: nginx
    kubernetes.io/tls-acme: "true"
  path: /
  hosts:
    - dex.k8s.example.com
  tls:
    - secretName: cert-auth-dex
      hosts:
        - dex.k8s.example.com
serviceAccount:
  create: true
  name: dex-auth-sa
config: |
  issuer: https://dex.k8s.example.com/
  storage: # https://github.com/dexidp/dex/issues/798
    type: sqlite3
    config:
      file: /var/dex.db
  web:
    http: 0.0.0.0:5556
  frontend:
    theme: "coreos"
    issuer: "Example Co"
    issuerUrl: "https://example.com"
    logoUrl: https://example.com/images/logo-250x25.png
  expiry:
    signingKeys: "6h"
    idTokens: "24h"
  logger:
    level: debug
    format: json
  oauth2:
    responseTypes: ["code", "token", "id_token"]
    skipApprovalScreen: true
  connectors:
  - type: github
    id: github
    name: GitHub
    config:
      clientID: $GITHUB_CLIENT_ID
      clientSecret: $GITHUB_CLIENT_SECRET
      redirectURI: https://dex.k8s.example.com/callback
      orgs:
      - name: super-org
        teams:
        - team-red
  staticClients:
  - id: dex-k8s-authenticator
    name: dex-k8s-authenticator
    secret: generatedLongRandomPhrase
    redirectURIs:
      - https://login.k8s.example.com/callback/
envSecrets:
  GITHUB_CLIENT_ID: "1ab2c3d4e5f6g7h8"
  GITHUB_CLIENT_SECRET: "98z76y54x32w1"
EOF

In za dex-k8s-authenticator:

cat << EOF > values-auth.yml
global:
  deployEnv: prod
dexK8sAuthenticator:
  clusters:
  - name: k8s.example.com
    short_description: "k8s cluster"
    description: "Kubernetes cluster"
    issuer: https://dex.k8s.example.com/
    k8s_master_uri: https://api.k8s.example.com
    client_id: dex-k8s-authenticator
    client_secret: generatedLongRandomPhrase
    redirect_uri: https://login.k8s.example.com/callback/
    k8s_ca_pem: |
      -----BEGIN CERTIFICATE-----
      AAAAAAAAAAABBBBBBBBBBCCCCCC
      -----END CERTIFICATE-----
ingress:
  enabled: true
  annotations:
    kubernetes.io/ingress.class: nginx
    kubernetes.io/tls-acme: "true"
  path: /
  hosts:
    - login.k8s.example.com
  tls:
    - secretName: cert-auth-login
      hosts:
        - login.k8s.example.com
EOF

Namestite Dex in dex-k8s-authenticator:

helm install -n dex --namespace kube-system --values values-dex.yml charts/dex
helm install -n dex-auth --namespace kube-system --values values-auth.yml charts/dex-k8s-authenticator

Preverimo delovanje storitev (Dex naj vrne kodo 400, dex-k8s-authenticator pa naj vrne kodo 200):

curl -sI https://dex.k8s.example.com/callback | head -1
HTTP/2 400
curl -sI https://login.k8s.example.com/ | head -1
HTTP/2 200

Konfiguracija RBAC

Ustvarimo ClusterRole za skupino, v našem primeru z dostopom samo za branje:

cat << EOF | kubectl create -f -
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: cluster-read-all
rules:
  -
    apiGroups:
      - ""
      - apps
      - autoscaling
      - batch
      - extensions
      - policy
      - rbac.authorization.k8s.io
      - storage.k8s.io
    resources:
      - componentstatuses
      - configmaps
      - cronjobs
      - daemonsets
      - deployments
      - events
      - endpoints
      - horizontalpodautoscalers
      - ingress
      - ingresses
      - jobs
      - limitranges
      - namespaces
      - nodes
      - pods
      - pods/log
      - pods/exec
      - persistentvolumes
      - persistentvolumeclaims
      - resourcequotas
      - replicasets
      - replicationcontrollers
      - serviceaccounts
      - services
      - statefulsets
      - storageclasses
      - clusterroles
      - roles
    verbs:
      - get
      - watch
      - list
  - nonResourceURLs: ["*"]
    verbs:
      - get
      - watch
      - list
  - apiGroups: [""]
    resources: ["pods/exec"]
    verbs: ["create"]
EOF

Ustvarimo konfiguracijo za ClusterRoleBinding:

cat <<EOF | kubectl create -f -
apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRoleBinding
metadata:
  name: dex-cluster-auth
  namespace: kube-system
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cluster-read-all
subjects:
  kind: Group
  name: "super-org:team-red"
EOF

Zdaj smo pripravljeni na testiranje.

Testi

Pojdite na stran za prijavo (https://login.k8s.example.com) in se prijavite s svojim računom GitHub:

Preverjanje pristnosti v Kubernetesu z uporabo GitHub OAuth in Dex
prijavna stran

Preverjanje pristnosti v Kubernetesu z uporabo GitHub OAuth in Dex
Stran za prijavo preusmerjena na GitHub

Preverjanje pristnosti v Kubernetesu z uporabo GitHub OAuth in Dex
 Za dostop sledite ustvarjenim navodilom

Po kopiranju in lepljenju s spletne strani lahko uporabimo kubectl za upravljanje naših virov gruče:

kubectl get po
NAME                READY   STATUS    RESTARTS   AGE
mypod               1/1     Running   0          3d

kubectl delete po mypod
Error from server (Forbidden): pods "mypod" is forbidden: User "[email protected]" cannot delete pods in the namespace "default"

In deluje, vsi uporabniki GitHub v naši organizaciji si lahko ogledajo vire in se prijavijo v sklope, vendar nimajo pravic, da bi jih spreminjali.

Vir: www.habr.com

Dodaj komentar