🥇Autentisering i Kubernetes med GitHub OAuth och Dex

Här presenterar jag en tutorial för att generera åtkomster till Kubernetes-klustret med hjälp av Dex, dex-k8s-authenticator och GitHub.

Ett lokalt meme från den ryskspråkiga Kubernetes-chatten i Telegram

Introduktion

Vi använder Kubernetes för att skapa dynamiska miljöer för utvecklar- och QA-teamet. På så sätt vill vi ge dem åtkomst till klustret både för dashboard och kubectl. Till skillnad från OpenShift har vanilj Kubernetes inget inbyggt autentisering, så vi använder tredjepartsverktyg för detta.

I denna konfiguration använder vi:

dex-k8s-authenticator — en webbapplikation för att generera kubectl-konfiguration
Dex — en OpenID Connect-leverantör
GitHub — helt enkelt för att vi använder GitHub i vårt företag.

Vi försökte använda Google OIDC, men tyvärr lyckades vi inte få det att fungera med grupper, så integrationen med GitHub passade oss bra. Utan grupplänkning går det inte att skapa RBAC-policyer baserade på grupper.

Så hur fungerar vår autentiseringsprocess i Kubernetes visuellt:

Autentiseringsprocessen

Lite mer i detalj, punkt för punkt:

Användaren loggar in på dex-k8s-authenticator (login.k8s.example.com)
dex-k8s-authenticator vidarebefordrar begäran till Dex (dex.k8s.example.com)
Dex vidarebefordrar till GitHubs inloggningssida
GitHub genererar nödvändig autentiseringsinformation och återvänder den till Dex
Dex vidarebefordrar den mottagna informationen till dex-k8s-authenticator
Användaren får en OIDC-token från GitHub
dex-k8s-authenticator lägger till token i kubeconfig
kubectl skickar token till KubeAPIServer
KubeAPIServer returnerar åtkomst till kubectl baserat på den angivna token
Användaren får åtkomst från kubectl

Förberedande åtgärder

Naturligtvis har vi redan en installerad Kubernetes-kluster (k8s.example.com), och HELM är också förinstallerat. Vi har även en organisation på GitHub (super-org).
Om du inte har HELM, installeras det väldigt enkelt.

Först måste vi konfigurera GitHub.

Gå till organisationsinställningssidan, (https://github.com/organizations/super-org/settings/applications) och skapa en ny applikation (Authorized OAuth App):

Skapa en ny applikation i GitHub

Fyll i fälten med nödvändiga URL:er, exempelvis:

Huvud-URL: https://dex.k8s.example.com
Autoriseringsåterkopplings-URL: https://dex.k8s.example.com/callback

Var försiktig med länkarna, det är viktigt att inte tappa bort snedstrecken.

Som svar på det ifyllda formuläret kommer GitHub att generera Klient-ID och Klienthemlighet, spara dem på en säker plats, vi kommer att behöva dem (vi använder exempelvis Vault för att lagra hemligheter):

Klient-ID: 1ab2c3d4e5f6g7h8
Klienthemlighet: 98z76y54x32w1

Förbered DNS-poster för subdomäner login.k8s.example.com och dex.k8s.example.com, samt SSL-certifikat för ingress.

Skapa SSL-certifikat:

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 med namnet le-clusterissuer måste redan finnas, om den inte gör det — låt oss skapa den med 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: k8s-admin@example.com
    privateKeySecretRef:
      name: le-clusterissuer
    http01: {}
EOF

KubeAPIServer-konfiguration

För att få kubeAPIServer att fungera måste OIDC konfigureras och klustret uppdateras:

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

Vi använder kops för att distribuera kluster, men detta fungerar på liknande sätt för andra klusterhanterare.

Dex och dex-k8s-authenticator-konfiguration

För att få Dex att fungera måste vi ha ett certifikat och en nyckel från Kubernetes-mastern, vi hämtar det därifrån:

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

Klonar dex-k8s-authenticator-repo:

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

Med hjälp av values-filer kan vi flexibelt konfigurera variabler för våra HELM-diagram.

Låt oss beskriva konfigurationen för Dex:

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

Och för dex-k8s-authenticator:

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

Låt oss installera Dex och 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

Vi kontrollerar att tjänsterna fungerar (Dex ska returnera kod 400, och dex-k8s-authenticator ska returnera kod 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-konfiguration

Vi skapar en ClusterRole för gruppen, i vårt fall med read-only behörigheter:

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

Vi skapar en konfiguration för 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

Nu är vi redo för testning.

Tester

Vi går till inloggningssidan (https://login.k8s.example.com) och loggar in med vårt GitHub-konto:

Inloggningssidan

Inloggningssidan omdirigeras till GitHub

Följ de genererade instruktionerna för att få åtkomst

Efter att ha kopierat och klistrat in från webbsidan kan vi använda kubectl för att hantera resurserna i vår kluster:

kubectl get po
NAMN                KLAR   STATUS    OMSTARTAR   ÅLDER
mypod               1/1     Körning   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"

Och det fungerar, alla GitHub-användare i vår organisation kan se resurserna och gå in i poddar, men de har inte rätt att ändra dem.

Källa: habr.com