🥇 Kubernetese autentimine GitHub OAuth ja Dex'i abil

Esitleme teile juhendit juurdepääsude genereerimiseks Kubernetes'i klastrisse Dex'i, dex-k8s-authenticator'i ja GitHub'i abil.

Kohalik meem Venemere Kubernetes'i vestlusgrupist Telegram

Sissejuhatus

Kasutame Kubernetes'i arendajate ja kvaliteedikontrolli meeskondade jaoks dünaamiliste keskkondade loomiseks. Seetõttu soovime anda neile juurdepääsu, nii klastrivaates kui ka kubectl'ile. Erinevalt OpenShift'ist ei paku puhtad Kubernetes'i lahendused vaikimisi autentimist, seega kasutame selleks kolmandate osapoolte tööriistu.

Käesolevas konfiguratsioonis kasutame:

dex-k8s-authenticator — veebirakendus kubectl'i konfi loomiseks
Dex — OpenID Connect'i pakkuja
GitHub — lihtsalt seetõttu, et kasutame GitHub'i oma ettevõttes

Püüdsime kasutada Google OIDC-d, kuid kahjuks ei õnnestunud gruppidega käivitada, seega sobis meile GitHub'i integreerimine. Ilma grupi kaardistamiseta ei õnnestu luua grupipõhiseid RBAC-poliitikaid.

Nii et kuidas meie autoriseerimisprotsess Kubernetes'is visuaalselt välja näeb:

Autoriseerimisprotsess

Veidi üksikasjalikumalt ja punktide kaupa:

Kasutaja logib sisse dex-k8s-authenticator'isse (login.k8s.example.com)
dex-k8s-authenticator suunab päringu Dex'i (dex.k8s.example.com)
Dex suunab GitHub'i autoriseerimise lehele
GitHub genereerib vajalikud autoriseerimise andmed ja saadab need tagasi Dex'ile
Dex edastab saadud andmed dex-k8s-authenticator'ile
Kasutaja saab GitHub'ist OIDC token'i
dex-k8s-authenticator lisab token'i kubeconfig'i
kubectl edastab token'i KubeAPIServer'isse
KubeAPIServer tagastab edastatud token'i põhjal juurdepääsud kubectl'ile
Kasutaja saab kubectl'ilt juurdepääsud

Ettevalmistavad toimingud

Iseenesest on meil juba installitud Kubernetes'i klaster (k8s.example.com), samuti on eelinstallitud HELM. Samuti on meil GitHub'is organisatsioon (super-org).
Kui teil ei ole HELM'i, siis selle installimine on väga lihtne.

Esmalt peame konfigureerima GitHub'i.

Liigume organisatsiooni seadete lehele, (https://github.com/organizations/super-org/settings/applications) ja loome uue rakenduse (Authorized OAuth App):

Uue rakenduse loomine GitHub'is

Täidame väljad vajalike URL-idega, näiteks:

Avalehe URL: https://dex.k8s.example.com
Autoriseerimise tagasiside URL: https://dex.k8s.example.com/callback

Olge lingide täitmisel ettevaatlik, oluline on mitte kaotada kaldkriipse.

Vastuseks täidetud vormile genereerib GitHub Client ID ja Client secret, hoidke need turvalises kohas, need tulevad meile kasuks (me näiteks kasutame Vault saladuste hoidmiseks):

Client ID: 1ab2c3d4e5f6g7h8
Client secret: 98z76y54x32w1

Valmistage ette DNS-kirjed alamdomeenide jaoks login.k8s.example.com ja dex.k8s.example.com, ning SSL-sertifikaadid ingresside jaoks.

Loome SSL-sertifikaadid:

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 nimega le-clusterissuer peab juba olemas olema, kui ei, loome selle HELM-i abil:

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: k8s-admin@example.com
    privateKeySecretRef:
      name: le-clusterissuer
    http01: {}
EOF

KubeAPIServer konfiguratsioon

KubeAPIServeri toimimiseks tuleb konfigureerida OIDC ja värskendada klastrit:

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

Me kasutame kops klastrite haldamiseks, kuid see töötab sarnaselt ka teiste klastri halduritega.

Dex ja dex-k8s-authenticatori konfiguratsioon

Dex toimimiseks on vajalik sertifikaat ja võti Kubernetes'i peamasinast, tõmbame selle sealt välja:

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

Kloonime dex-k8s-authenticatori reposti:

git clone git@github.com:mintel/dex-k8s-authenticator.git
cd dex-k8s-authenticator/

Kasutades values-faile, saame paindlikult seadistada muutujaid meie HELM-i graafikute jaoks.

Kohandame Dex jaoks konfiguratsiooni:

cat < 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

Ja dex-k8s-authenticator jaoks:

cat < values-auth.yml
global:
  deployEnv: prod
dexK8sAuthenticator:
  clusters:
  - name: k8s.example.com
    short_description: "k8s klaster"
    description: "Kubernetes klaster"
    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

Installime Dex ja 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

Kontrollime teenuste toimivust (Dex peaks tagastama koodi 400 ja dex-k8s-authenticator koodi 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 konfiguratsioon

Loome ClusterRole grupile, mis on meie juhul read-only õigustega:

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

Loome konfiguratsioon ClusterRoleBinding'ile:

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

Nüüd oleme valmis testimiseks.

Testid

Liigume sisselogimise lehe juurde (https://login.k8s.example.com) ja logime sisse GitHubi kontoga:

Sisselogimise leht

Sisselogimise leht, millel on suunamine GitHubi

Järgime genereeritud juhiseid ligipääsude saamiseks

Pärast veebilehelt kopeerimist ja kleepimist saame kasutada kubectl'i oma klastrite ressursside haldamiseks:

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 "amet@example.com" cannot delete pods in the namespace "default"

Ja see töötab, kõik GitHubi kasutajad meie organisatsioonis saavad ressursse vaadata ja pod'desse siseneda, kuid neil ei ole õigusi nende muutmiseks.

Allikas: habr.com

Kubernetesi autentimine GitHub OAuthi ja Dexi abil