ProHoster > Blogi > Haldamine > Kuberneteses autentimine GitHub OAuth ja Dex kaudu

Kuberneteses autentimine GitHub OAuth ja Dex kaudu

Esitan teile Kubernetes-klastrite juurdepääsu genereerimise õpetuse, kasutades Dex'i, dex-k8s-authenticator'i ja GitHub'i.

Kuberneteses autentimine GitHub OAuth ja Dex kaudu
Kohalik meem Venemaalt Kubernetes'i vestlusest Telegram

Sissejuhatus

Kasutame Kubernetes'e, et luua dünaamilisi keskkondi arendajate ja QA meeskonna jaoks. Seetõttu soovime pakkuda neile juurdepääsu klastrile nii juhtpaneeli kui ka kubectl'i jaoks. Erinevalt OpenShift'ist ei oma puhas Kubernetes natiivset autentimist, seega kasutame seda otstarbeks kolmanda osapoole lahendusi.

Selles konfiguratsioonis kasutame:

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

Proovime kasutada Google OIDC-d, kuid kahjuks ei suutnud me seda seadistada rühmadega, seega sobis meile täielikult GitHub'i integratsioon. Ilma rühmade kaardistamiseta ei suuda luua RBAC-poliitikaid, mis põhinevad gruppidel.

Nii et kuidas meie autoriseerimisprotsess Kuberneteses visuaalselt välja näeb:

Kuberneteses autentimine GitHub OAuth ja Dex kaudu
Autoriseerimisprotsess

Veidi põhjalikumalt ja punktide kaupa:

  1. Kasutaja logib sisse dex-k8s-authenticator'isse (login.k8s.example.com)
  2. dex-k8s-authenticator suunab päringu Dex'i (dex.k8s.example.com)
  3. Dex suunab teid GitHubi autentimise lehele
  4. GitHub genereerib vajalikud autentimise andmed ja edastab need Dex-ile
  5. Dex edastab saadud andmed dex-k8s-authenticator-ile
  6. Kasutaja saab OIDC tokeni GitHubist
  7. dex-k8s-authenticator lisab tokeni kubeconfig faili
  8. kubectl edastab tokeni KubeAPIServerile
  9. KubeAPIServer väljastab edastatud tokeni alusel juurdepääsu kubectl-ile
  10. Kasutaja saab kubectl-ilt õigused

Ettevalmistavad teod

Kubernetes klaster on meil juba seadistatud (k8s.example.com), samuti on HELM eelnevalt installitud. Samuti on meil GitHubis organisatsioon (super-org).
Kui sul ei ole HELM-i, siis selle installimine on väga lihtne.

Esmalt peame seadistama GitHubi.

Liigu organisatsiooni seadetesse, (https://github.com/organizations/super-org/settings/applications) ja loo uus rakendus (Authorized OAuth App):
Kuberneteses autentimine GitHub OAuth ja Dex kaudu
Uue rakenduse loomine GitHubis

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

  • Avalehe URL: https://dex.k8s.example.com
  • Autentimise tagasikutsumise URL: https://dex.k8s.example.com/callback

Ole ettevaatlik linkide puhul, oluline on mitte kaotada kaldu.

Vastuseks täidetud vormile genereerib GitHub Kliendi ID ja Klientide salajase võtme, säilita need turvalises kohas, need tulevad meil kasuks (näiteks kasutame me Vault saladuste hoidmiseks):

Klientide ID: 1ab2c3d4e5f6g7h8
Klientide salajane võti: 98z76y54x32w1

Valmista ette DNS-kanded alamdomeenide jaoks login.k8s.example.com ja dex.k8s.example.com, samuti SSL-sertifikaadid sissetulekute 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 eksisteerima, 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

KubeAPIServeri konfiguratsioon

KubeAPIServeri rakendamiseks on vajalik OIDC konfigureerimine ja klastri uuendamine:

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 käitamiseks, kuid see töötab samuti ka teiste klastrihaldurite puhul.

Dexi ja dex-k8s-authenticatori konfiguratsioon

Dexi tööks on vajalik sertifikaat ja võtme Kubernetes'i pealmest, saame selle sealt kätte:

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 repo:

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

Kasutades values-failide, saame elastsemalt seadistada muutujaid meie HELM-i chartide jaoks.

Kirjeldame Dexi konfiguratsiooni:

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

Ja dex-k8s-authenticator jaoks:

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

Paigaldame 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, 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, meie juhul lugemisõ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 lehele (https://login.k8s.example.com) ja logime sisse oma GitHubi kontoga:

Kuberneteses autentimine GitHub OAuth ja Dex kaudu
Sisselogimise leht

Kuberneteses autentimine GitHub OAuth ja Dex kaudu
Sisselogimise leht, mille on suunanud GitHub

Kuberneteses autentimine GitHub OAuth ja Dex kaudu
 Järgige genereeritud juhiseid ligipääsute saamiseks.

Pärast veebilehe kopeerimist saame kasutada kubectl-i meie 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 näha ressursse ja siseneda podidesse, kuid nad ei oma õigusi nende muutmiseks.

Allikas: habr.com

Osta usaldusväärne veebihosting DDoS kaitsega, VPS VDS serverid 🔥 Osta usaldusväärne veebihosting DDoS kaitsega, VPS VDS serverid | ProHoster