🥇Autentifikavimas Kubernetes naudojant GitHub OAuth ir Dex

Pristatau jūsų dėmesiui mokymo programą, kaip sukurti prieigą prie „Kubernetes“ klasterio naudojant „Dex“, „dex-k8s-autenticator“ ir „GitHub“.

Vietinis memas iš rusų kalbos „Kubernetes“ kalbasi Telegram

įvedimas

Naudojame Kubernetes, kad sukurtume dinamišką aplinką kūrimo ir kokybės užtikrinimo komandai. Taigi norime suteikti jiems prieigą prie informacijos suvestinės ir „kubectl“ grupės. Skirtingai nei „OpenShift“, „vanilla Kubernetes“ neturi vietinio autentifikavimo, todėl tam naudojame trečiųjų šalių įrankius.

Šioje konfigūracijoje naudojame:

dex-k8s-autentifikatorius - žiniatinklio programa, skirta generuoti kubectl konfigūraciją
dex — OpenID Connect teikėjas
„GitHub“ – tiesiog todėl, kad savo įmonėje naudojame „GitHub“.

Bandėme naudoti Google OIDC, bet, deja, mes nepavyko pradėti juos su grupėmis, todėl integracija su GitHub mums labai tiko. Be grupės susiejimo nebus įmanoma sukurti RBAC politikos pagal grupes.

Taigi, kaip veikia mūsų „Kubernetes“ autorizacijos procesas vaizdinėje pavyzdyje:

Autorizacijos procesas

Šiek tiek detaliau ir taškas po taško:

Vartotojas prisijungia prie dex-k8s-authenticator (login.k8s.example.com)
dex-k8s-autenticatorius persiunčia užklausą Dex (dex.k8s.example.com)
„Dex“ nukreipia į „GitHub“ prisijungimo puslapį
„GitHub“ sugeneruoja reikiamą leidimo informaciją ir grąžina ją „Dex“.
Dex perduoda gautą informaciją dex-k8s-autenticatoriui
Vartotojas gauna OIDC prieigos raktą iš „GitHub“.
dex-k8s-autenticatorius prideda prieigos raktą prie kubeconfig
kubectl perduoda prieigos raktą KubeAPIServer
„KubeAPIServer“ grąžina prieigą prie „kubectl“ pagal perduotą prieigos raktą
Vartotojas gauna prieigą iš kubectl

Parengiamieji veiksmai

Žinoma, jau turime įdiegtą Kubernetes klasterį (k8s.example.com), taip pat yra iš anksto įdiegtas HELM. Mes taip pat turime organizaciją GitHub (super-org).
Jei neturite HELM, įdiekite jį labai paprasta.

Pirmiausia turime nustatyti „GitHub“.

Eikite į organizacijos nustatymų puslapį, (https://github.com/organizations/super-org/settings/applications) ir sukurkite naują programą (įgaliotą OAuth programą):

Naujos programos kūrimas „GitHub“.

Užpildykite laukus reikiamais URL, pavyzdžiui:

Pagrindinio puslapio URL: https://dex.k8s.example.com
Prieigos grąžinimo URL: https://dex.k8s.example.com/callback

Būkite atsargūs su nuorodomis, svarbu neprarasti pasvirųjų brūkšnių.

Atsakydamas į užpildytą formą, „GitHub“ sugeneruos Client ID и Client secret, laikykite juos saugioje vietoje, jie mums pravers (pavyzdžiui, naudojame Vault paslapčių saugojimui):

Client ID: 1ab2c3d4e5f6g7h8
Client secret: 98z76y54x32w1

Paruoškite padomenių DNS įrašus login.k8s.example.com и dex.k8s.example.com, taip pat įėjimo SSL sertifikatus.

Sukurkime SSL sertifikatus:

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 su pavadinimu le-clusterissuer jau turėtų egzistuoti, bet jei ne, sukurkite jį naudodami 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

KubeAPIServer konfigūracija

Kad kubeAPIServer veiktų, turite sukonfigūruoti OIDC ir atnaujinti klasterį:

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

Mes naudojame spardyti klasterių diegimui, tačiau tai veikia panašiai kiti klasterių vadovai.

Dex konfigūracija ir dex-k8s-autentifikatorius

Kad Dex veiktų, reikia turėti sertifikatą ir raktą iš Kubernetes meistro, gaukime jį iš ten:

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

Klonuokime dex-k8s-autentifikatoriaus saugyklą:

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

Naudodami reikšmių failus, galime lanksčiai konfigūruoti savo kintamuosius HELM diagramos.

Apibūdinkime „Dex“ konfigūraciją:

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

Ir dex-k8s-autenticatoriui:

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

Įdiekite „Dex“ ir „dex-k8s-autentifikatorių“:

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

Patikrinkime paslaugų funkcionalumą (Dex turėtų grąžinti kodą 400, o dex-k8s-autenticatorius – 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

RBAC konfigūracija

Grupei sukuriame ClusterRole, mūsų atveju su tik skaitymo prieiga:

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

Sukurkime ClusterRoleBinding konfigūraciją:

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

Dabar esame pasiruošę bandymams.

Testai

Eikite į prisijungimo puslapį (https://login.k8s.example.com) ir prisijunkite naudodami savo GitHub paskyrą:

Prisijungimo puslapis

Prisijungimo puslapis nukreiptas į „GitHub“.

Vykdykite sugeneruotas instrukcijas, kad gautumėte prieigą

Nukopijavę įklijavimą iš tinklalapio, galime naudoti kubectl savo klasterio ištekliams tvarkyti:

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"

Ir tai veikia, visi mūsų organizacijos „GitHub“ naudotojai gali matyti išteklius ir prisijungti prie podių, tačiau neturi teisės jų keisti.

Šaltinis: www.habr.com

Autentifikuokite „Kubernetes“ naudodami „GitHub OAuth“ ir „Dex“.