ProHoster > Blogs > Administrācija > Autentificējieties pakalpojumā Kubernetes, izmantojot GitHub OAuth un Dex

Autentificējieties pakalpojumā Kubernetes, izmantojot GitHub OAuth un Dex

Es piedāvāju jūsu uzmanībai apmācību, lai izveidotu piekļuvi Kubernetes klasterim, izmantojot Dex, dex-k8s-autentifikatoru un GitHub.

Autentificējieties pakalpojumā Kubernetes, izmantojot GitHub OAuth un Dex
Vietējais mēms no krievu valodas Kubernetes tērzē Telegram

Ievads

Mēs izmantojam Kubernetes, lai izveidotu dinamisku vidi izstrādes un kvalitātes nodrošināšanas komandai. Tāpēc mēs vēlamies viņiem nodrošināt piekļuvi klasterim gan informācijas panelim, gan kubectl. Atšķirībā no OpenShift, vaniļas Kubernetes nav vietējās autentifikācijas, tāpēc mēs izmantojam trešo pušu rīkus.

Šajā konfigurācijā mēs izmantojam:

  • dex-k8s-autentifikators  — tīmekļa lietojumprogramma kubectl konfigurācijas ģenerēšanai
  • Dex — OpenID Connect nodrošinātājs
  • GitHub — vienkārši tāpēc, ka mēs savā uzņēmumā izmantojam GitHub

Mēs mēģinājām izmantot Google OIDC, bet diemžēl mēs neizdevās lai sāktu tos ar grupām, tāpēc integrācija ar GitHub mums bija diezgan piemērota. Bez grupu kartēšanas nebūs iespējams izveidot uz grupām balstītas RBAC politikas.

Tātad, kā mūsu Kubernetes autorizācijas process darbojas vizuālā attēlojumā:

Autentificējieties pakalpojumā Kubernetes, izmantojot GitHub OAuth un Dex
Autorizācijas process

Nedaudz sīkāk un punktu pa punktam:

  1. Lietotājs piesakās dex-k8s-authenticator (login.k8s.example.com)
  2. dex-k8s-authenticator pārsūta pieprasījumu Dex (dex.k8s.example.com)
  3. Dex novirza uz GitHub pieteikšanās lapu
  4. GitHub ģenerē nepieciešamo autorizācijas informāciju un nosūta to atpakaļ Dex
  5. Dex nodod saņemto informāciju dex-k8s-autentifikatoram
  6. Lietotājs saņem OIDC marķieri no GitHub
  7. dex-k8s-autentifikators pievieno marķieri kubeconfig
  8. kubectl nodod marķieri KubeAPIServer
  9. KubeAPIServer atgriež piekļuvi kubectl, pamatojoties uz nodoto pilnvaru
  10. Lietotājs iegūst piekļuvi no kubectl

Sagatavošanas aktivitātes

Protams, mums jau ir instalēts Kubernetes klasteris (k8s.example.com), un komplektācijā ir arī iepriekš instalēts HELM. Mums ir arī organizācija GitHub (super-org).
Ja jums nav HELM, instalējiet to ļoti vienkārši.

Vispirms mums ir jāiestata GitHub.

Dodieties uz organizācijas iestatījumu lapu, (https://github.com/organizations/super-org/settings/applications) un izveidojiet jaunu lietojumprogrammu (autorizēta OAuth lietotne):
Autentificējieties pakalpojumā Kubernetes, izmantojot GitHub OAuth un Dex
Jaunas lietojumprogrammas izveide vietnē GitHub

Aizpildiet laukus ar nepieciešamajiem URL, piemēram:

  • Mājas lapas URL: https://dex.k8s.example.com
  • Autorizācijas atzvanīšanas URL: https://dex.k8s.example.com/callback

Esiet uzmanīgi ar saitēm, ir svarīgi nezaudēt slīpsvītras.

Atbildot uz aizpildītu veidlapu, GitHub ģenerēs Client ID и Client secret, glabājiet tos drošā vietā, tie mums noderēs (piemēram, lietojam Velvēt noslēpumu glabāšanai):

Client ID: 1ab2c3d4e5f6g7h8
Client secret: 98z76y54x32w1

Sagatavojiet DNS ierakstus apakšdomēniem login.k8s.example.com и dex.k8s.example.com, kā arī SSL sertifikāti iekļūšanai.

Izveidosim SSL sertifikātus:

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 ar nosaukumu le-clusterissuer jau vajadzētu pastāvēt, bet, ja nē, izveidojiet to, izmantojot 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 konfigurācija

Lai kubeAPIServer darbotos, jums ir jākonfigurē OIDC un jāatjaunina klasteris:

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

Mēs izmantojam sitiens klasteru izvietošanai, bet tas darbojas līdzīgi citi klasteru vadītāji.

Dex konfigurācija un dex-k8s-autentifikators

Lai Dex darbotos, jums ir jābūt sertifikātam un atslēgai no Kubernetes meistara, iegūsim to no turienes:

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

Klonēsim dex-k8s-autentifikatora repozitoriju:

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

Izmantojot vērtību failus, mēs varam elastīgi konfigurēt mūsu mainīgos HELM diagrammas.

Aprakstīsim Dex konfigurāciju:

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

Un dex-k8s-autentifikatoram:

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

Instalējiet Dex un dex-k8s-autentifikatoru:

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

Pārbaudīsim pakalpojumu funkcionalitāti (Dex ir jāatgriež kods 400, bet dex-k8s-autenticatoram jāatgriež kods 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 konfigurācija

Mēs izveidojam grupai ClusterRole, mūsu gadījumā ar tikai lasīšanas piekļuvi:

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

Izveidosim ClusterRoleBinding konfigurāciju:

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

Tagad esam gatavi testēšanai.

Testi

Dodieties uz pieteikšanās lapu (https://login.k8s.example.com) un piesakieties, izmantojot savu GitHub kontu:

Autentificējieties pakalpojumā Kubernetes, izmantojot GitHub OAuth un Dex
Pieteikšanās lapa

Autentificējieties pakalpojumā Kubernetes, izmantojot GitHub OAuth un Dex
Pieteikšanās lapa ir novirzīta uz GitHub

Autentificējieties pakalpojumā Kubernetes, izmantojot GitHub OAuth un Dex
 Izpildiet izveidotos norādījumus, lai piekļūtu

Pēc kopēšanas un ielīmēšanas no tīmekļa lapas mēs varam izmantot kubectl, lai pārvaldītu mūsu klastera resursus:

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"

Un tas darbojas, visi GitHub lietotāji mūsu organizācijā var redzēt resursus un pieteikties podiņos, taču viņiem nav tiesību tos mainīt.

Avots: www.habr.com

Pievieno komentāru