ProHoster > Blog > administratë > Vërtetoni në Kubernetes duke përdorur GitHub OAuth dhe Dex

Vërtetoni në Kubernetes duke përdorur GitHub OAuth dhe Dex

Unë paraqes në vëmendjen tuaj një tutorial për gjenerimin e aksesit në një grupim Kubernetes duke përdorur Dex, dex-k8s-authenticator dhe GitHub.

Vërtetoni në Kubernetes duke përdorur GitHub OAuth dhe Dex
Meme lokale nga biseda në gjuhën ruse Kubernetes në Telegram

Paraqitje

Ne përdorim Kubernetes për të krijuar mjedise dinamike për ekipin e zhvillimit dhe QA. Pra, ne duam t'u japim atyre akses në grup si për pultin ashtu edhe për kubectl. Ndryshe nga OpenShift, vanilla Kubernetes nuk ka vërtetim origjinal, kështu që ne përdorim mjete të palëve të treta për këtë.

Në këtë konfigurim ne përdorim:

  • dex-k8s-authenticator  — aplikacion në internet për gjenerimin e konfigurimit kubectl
  • Dex — Ofruesi i OpenID Connect
  • GitHub - thjesht sepse ne përdorim GitHub në kompaninë tonë

Ne u përpoqëm të përdornim Google OIDC, por për fat të keq ne dështuar për t'i nisur me grupe, kështu që integrimi me GitHub na përshtatej mjaft mirë. Pa hartimin e grupeve, nuk do të jetë e mundur të krijohen politika RBAC bazuar në grupe.

Pra, si funksionon procesi ynë i autorizimit Kubernetes në një paraqitje vizuale:

Vërtetoni në Kubernetes duke përdorur GitHub OAuth dhe Dex
Procesi i autorizimit

Pak më shumë detaje dhe pikë për pikë:

  1. Përdoruesi regjistrohet në dex-k8s-authenticator (login.k8s.example.com)
  2. dex-k8s-authenticator ia përcjell kërkesën Dex (dex.k8s.example.com)
  3. Dex ridrejtohet në faqen e hyrjes në GitHub
  4. GitHub gjeneron informacionin e nevojshëm të autorizimit dhe e kthen atë në Dex
  5. Dex ia kalon informacionin e marrë dex-k8s-authenticator
  6. Përdoruesi merr një shenjë OIDC nga GitHub
  7. dex-k8s-authenticator shton token në kubeconfig
  8. kubectl ia kalon tokenin KubeAPIServer
  9. KubeAPIServer kthen akses në kubectl bazuar në tokenin e kaluar
  10. Përdoruesi merr akses nga kubectl

Aktivitetet përgatitore

Sigurisht, ne tashmë kemi të instaluar një grup Kubernetes (k8s.example.com), dhe gjithashtu vjen me HELM të para-instaluar. Ne gjithashtu kemi një organizatë në GitHub (super-org).
Nëse nuk keni HELM, instaloni atë shumë e thjeshtë.

Fillimisht duhet të konfigurojmë GitHub.

Shkoni te faqja e cilësimeve të organizatës, (https://github.com/organizations/super-org/settings/applications) dhe krijoni një aplikacion të ri (Aplikacion i autorizuar OAuth):
Vërtetoni në Kubernetes duke përdorur GitHub OAuth dhe Dex
Krijimi i një aplikacioni të ri në GitHub

Plotësoni fushat me URL-të e nevojshme, për shembull:

  • URL e faqes kryesore: https://dex.k8s.example.com
  • URL-ja e kthimit të thirrjes së autorizimit: https://dex.k8s.example.com/callback

Kini kujdes me lidhjet, është e rëndësishme që të mos humbni prerjet.

Në përgjigje të një formulari të plotësuar, GitHub do të gjenerojë Client ID и Client secret, mbajini në një vend të sigurt, ato do të jenë të dobishme për ne (për shembull, ne i përdorim Kasafortë për ruajtjen e sekreteve):

Client ID: 1ab2c3d4e5f6g7h8
Client secret: 98z76y54x32w1

Përgatitni regjistrimet DNS për nënfushat login.k8s.example.com и dex.k8s.example.com, si dhe certifikatat SSL për hyrje.

Le të krijojmë certifikata SSL:

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 me titull le-clusterissuer duhet të ekzistojë tashmë, por nëse jo, krijoni atë duke përdorur 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

Konfigurimi i KubeAPIServer

Që kubeAPIServer të funksionojë, duhet të konfiguroni OIDC dhe të përditësoni grupin:

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

Ne përdorim goditje me shkelm për vendosjen e grupimeve, por kjo funksionon në mënyrë të ngjashme për menaxherët e tjerë të grupimeve.

Konfigurimi Dex dhe vërtetuesi i dex-k8s

Që Dex të funksionojë, ju duhet të keni një certifikatë dhe një çelës nga mjeshtri i Kubernetes, le ta marrim nga atje:

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

Le të klonojmë depon e dex-k8s-authenticator:

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

Duke përdorur skedarët e vlerave, ne mund të konfigurojmë në mënyrë fleksibël variablat për tonat Listat HELM.

Le të përshkruajmë konfigurimin për Dex:

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

Dhe për dex-k8s-authenticator:

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

Instaloni Dex dhe 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

Le të kontrollojmë funksionalitetin e shërbimeve (Dex duhet të kthejë kodin 400, dhe dex-k8s-authenticator duhet të kthejë kodin 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

Konfigurimi RBAC

Ne krijojmë një ClusterRole për grupin, në rastin tonë me akses vetëm për lexim:

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

Le të krijojmë një konfigurim pë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

Tani jemi gati për testim.

testet

Shkoni në faqen e hyrjes (https://login.k8s.example.com) dhe identifikohuni duke përdorur llogarinë tuaj GitHub:

Vërtetoni në Kubernetes duke përdorur GitHub OAuth dhe Dex
Faqja e hyrjes

Vërtetoni në Kubernetes duke përdorur GitHub OAuth dhe Dex
Faqja e hyrjes u ridrejtua në GitHub

Vërtetoni në Kubernetes duke përdorur GitHub OAuth dhe Dex
 Ndiqni udhëzimet e krijuara për të fituar akses

Pas kopjimit nga faqja e internetit, ne mund të përdorim kubectl për të menaxhuar burimet tona të grupimit:

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"

Dhe funksionon, të gjithë përdoruesit e GitHub në organizatën tonë mund të shohin burimet dhe të hyjnë në pods, por ata nuk kanë të drejtë t'i ndryshojnë ato.

Burimi: www.habr.com

Shto një koment