An ABC of Security in Kubernetes: Fíordheimhniú, Údarú, Iniúchóireacht

Luath nó mall, i bhfeidhmiú aon chórais, tagann saincheist na slándála chun cinn: fíordheimhniú, scaradh cearta, iniúchadh agus tascanna eile a chinntiú. Cruthaithe cheana féin le haghaidh Kubernetes go leor réitigh, a ligeann duit comhlíonadh na gcaighdeán a bhaint amach fiú i dtimpeallachtaí an-éilitheacha... Tá an t-ábhar céanna dírithe ar ghnéithe bunúsacha na slándála a chuirtear i bhfeidhm laistigh de mheicníochtaí ionsuite na K8anna. Ar an gcéad dul síos, beidh sé úsáideach dóibh siúd atá ag tosú aithne a chur ar Kubernetes - mar phointe tosaigh chun staidéar a dhéanamh ar shaincheisteanna a bhaineann le slándáil.

Fíordheimhniú

Tá dhá chineál úsáideoirí i Kubernetes:

• Cuntais Seirbhíse — cuntais arna mbainistiú ag Kubernetes API;
• Users — “gnáthúsáideoirí” arna mbainistiú ag seirbhísí neamhspleácha seachtracha.

Is í an phríomhdhifríocht idir na cineálacha seo ná go bhfuil rudaí speisialta in Kubernetes API le haghaidh Cuntais Seirbhíse (tugtar - ServiceAccounts), atá ceangailte le hainmspás agus le sraith sonraí údaraithe atá stóráilte sa bhraisle i réada den chineál Rúin. Tá sé mar aidhm ag úsáideoirí den sórt sin (Cuntais Seirbhíse) go príomha cearta rochtana ar API Kubernetes de phróisis a ritheann i mbraisle Kubernetes a bhainistiú.

Níl iontrálacha ag Gnáthúsáideoirí in API Kubernetes: ní mór iad a bhainistiú le meicníochtaí seachtracha. Tá siad ceaptha do dhaoine nó do phróisis atá ina gcónaí lasmuigh den bhraisle.

Baineann gach iarratas API le Cuntas Seirbhíse, le hÚsáideoir, nó meastar é a bheith gan ainm.

Áirítear le sonraí fíordheimhnithe úsáideora:

• Ainm úsáideora — ainm úsáideora (cás íogair!);
• UID - teaghrán aitheantais úsáideora meaisín-inléite atá “níos comhsheasmhaí agus níos uathúla ná an t-ainm úsáideora”;
• grúpaí — liosta de na grúpaí lena mbaineann an t-úsáideoir;
• breise — réimsí breise is féidir leis an meicníocht údaraithe a úsáid.

Is féidir le Kubernetes líon mór meicníochtaí fíordheimhnithe a úsáid: deimhnithe X509, comharthaí Iompróra, seachfhreastalaí fíordheimhnithe, HTTP Basic Auth. Ag baint úsáide as na meicníochtaí seo, is féidir leat líon mór scéimeanna údaraithe a chur i bhfeidhm: ó chomhad statach le pasfhocail go OpenID OAuth2.

Ina theannta sin, is féidir roinnt scéimeanna údaraithe a úsáid go comhuaineach. De réir réamhshocraithe, úsáideann an braisle:

• comharthaí cuntais seirbhíse - le haghaidh Cuntas Seirbhíse;
• X509 - le haghaidh Úsáideoirí.

Tá an cheist faoi bhainistiú ServiceAccounts lasmuigh de raon feidhme an ailt seo, ach dóibh siúd ar mian leo eolas níos mine a fháil ar an gceist seo, molaim tosú le leathanaigh doiciméad oifigiúil. Déanfaimid breathnú níos dlúithe ar an tsaincheist maidir le conas a oibríonn deimhnithe X509.

Deimhnithe d'úsáideoirí (X.509)

Is éard atá i gceist leis an mbealach clasaiceach chun oibriú le deimhnithe:

• eochairghlúin:

  mkdir -p ~/mynewuser/.certs/
  openssl genrsa -out ~/.certs/mynewuser.key 2048

• iarratas ar dheimhniú a ghiniúint:

  openssl req -new -key ~/.certs/mynewuser.key -out ~/.certs/mynewuser.csr -subj "/CN=mynewuser/O=company"

• iarratas ar dheimhniú a phróiseáil ag baint úsáide as eochracha CA braisle Kubernetes, teastas úsáideora a fháil (chun teastas a fháil, ní mór duit cuntas a úsáid a bhfuil rochtain aige ar eochair CA braisle Kubernetes, atá suite i réamhshocraithe /etc/kubernetes/pki/ca.key):

  openssl x509 -req -in ~/.certs/mynewuser.csr -CA /etc/kubernetes/pki/ca.crt -CAkey /etc/kubernetes/pki/ca.key -CAcreateserial -out ~/.certs/mynewuser.crt -days 500

• ag cruthú comhad cumraíochta:
  • cur síos braisle (sonraigh seoladh agus suíomh an chomhaid deimhnithe CA le haghaidh suiteáil bhraisle ar leith):

    kubectl config set-cluster kubernetes --certificate-authority=/etc/kubernetes/pki/ca.crt --server=https://192.168.100.200:6443

  • nó conas aonrogha mholta - ní gá duit an teastas fréimhe a shonrú (ansin ní seiceálfaidh kubectl cruinneas api-fhreastalaí an bhraisle):

    kubectl config set-cluster kubernetes  --insecure-skip-tls-verify=true --server=https://192.168.100.200:6443

  • úsáideoir a chur leis an gcomhad cumraíochta:

    kubectl config set-credentials mynewuser --client-certificate=.certs/mynewuser.crt  --client-key=.certs/mynewuser.key

  • ag cur comhthéacs leis:

    kubectl config set-context mynewuser-context --cluster=kubernetes --namespace=target-namespace --user=mynewuser

  • tasc réamhshocraithe comhthéacs:

    kubectl config use-context mynewuser-context

Tar éis na manipulations thuas, sa chomhad .kube/config cruthófar cumraíocht mar seo:

apiVersion: v1
clusters:
- cluster:
    certificate-authority: /etc/kubernetes/pki/ca.crt
    server: https://192.168.100.200:6443
  name: kubernetes
contexts:
- context:
    cluster: kubernetes
    namespace: target-namespace
    user: mynewuser
  name: mynewuser-context
current-context: mynewuser-context
kind: Config
preferences: {}
users:
- name: mynewuser
  user:
    client-certificate: /home/mynewuser/.certs/mynewuser.crt
    client-key: /home/mynewuser/.certs/mynewuser.key

Chun é a dhéanamh níos éasca an chumraíocht a aistriú idir cuntais agus freastalaithe, tá sé úsáideach luachanna na n-eochracha seo a leanas a chur in eagar:

• certificate-authority
• client-certificate
• client-key

Chun seo a dhéanamh, is féidir leat na comhaid sonraithe iontu a ionchódú ag baint úsáide as base64 agus iad a chlárú sa chumraíocht, ag cur an iarmhír le hainm na n-eochracha -data, i.e. tar éis a fháil certificate-authority-data etc

Deimhnithe le kubeadm

Leis an scaoileadh Cúirtéis 1.15 tá sé i bhfad níos éasca oibriú le deimhnithe a bhuíochas leis an leagan alfa dá thacaíocht i fóntais kubeadm. Mar shampla, is é seo an chuma a bheadh ​​ar chomhad cumraíochta a ghiniúint le heochracha úsáideora anois:

kubeadm alpha kubeconfig user --client-name=mynewuser --apiserver-advertise-address 192.168.100.200

NB: Ag teastáil seoladh a fhógairt le fáil sa chumraíocht api-server, atá suite i réamhshocraithe /etc/kubernetes/manifests/kube-apiserver.yaml.

Déanfar an chumraíocht a bheidh mar thoradh air a aschur go stdout. Ní mór é a shábháil i ~/.kube/config chuntas úsáideora nó chuig comhad atá sonraithe in athróg timpeallachta KUBECONFIG.

Tochailt níos doimhne

Dóibh siúd ar mian leo tuiscint níos cruinne a fháil ar na saincheisteanna a gcuirtear síos orthu:

• alt ar leithligh ar oibriú le deimhnithe i gcáipéisíocht oifigiúil Kubernetes;
• alt maith ó Bitnami, ina bpléitear go praiticiúil le heisiúint teastais.
• doiciméadú ginearálta maidir le fíordheimhniú i Kubernetes.

Údarú

Níl cearta ag an gcuntas údaraithe réamhshocraithe oibriú ar an mbraisle. Chun ceadanna a dheonú, cuireann Kubernetes meicníocht údaraithe i bhfeidhm.

Roimh leagan 1.6, d'úsáid Kubernetes cineál údaraithe ar a dtugtar ABAC (Rialú rochtana bunaithe ar thréithe). Is féidir sonraí faoi a fháil i doiciméadú oifigiúil. Meastar go bhfuil an cur chuige seo mar oidhreacht faoi láthair, ach is féidir leat é a úsáid fós taobh le cineálacha fíordheimhnithe eile.

Tugtar an bealach reatha (agus níos solúbtha) chun cearta rochtana ar bhraisle a roinnt RBAC (Rialú rochtana bunaithe ar ról). Tá sé dearbhaithe cobhsaí ó leagan Cúirtéis 1.8. Cuireann RBAC múnla cearta i bhfeidhm ina gcuirtear cosc ​​ar gach rud nach bhfuil ceadaithe go sainráite.
Chun RBAC a chumasú, ní mór duit Kubernetes api-server a thosú leis an bparaiméadar --authorization-mode=RBAC. Socraítear na paraiméadair sa léiriú leis an gcumraíocht api-server, atá suite feadh an chosáin de réir réamhshocraithe /etc/kubernetes/manifests/kube-apiserver.yaml, in alt command. Mar sin féin, tá RBAC cumasaithe cheana féin de réir réamhshocraithe, mar sin is dócha nár cheart duit a bheith buartha faoi: is féidir leat é seo a fhíorú leis an luach authorization-mode (sa luadh cheana kube-apiserver.yaml). Dála an scéil, i measc a bríonna d'fhéadfadh go mbeadh cineálacha eile údaraithe (node, webhook, always allow), ach fágfaimid a gcomaoin lasmuigh de raon feidhme an ábhair.

Dála an scéil, tá foilsithe againn cheana féin Airteagal le cur síos measartha mionsonraithe ar na prionsabail agus na gnéithe a bhaineann le bheith ag obair le RBAC, mar sin beidh mé teoranta do liosta gairid de na bunghnéithe agus samplaí.

Úsáidtear na heintitis API seo a leanas chun rochtain in Kubernetes a rialú trí RBAC:

• Role и ClusterRole — róil a fheidhmíonn chun cur síos a dhéanamh ar chearta rochtana:
• Role ligeann duit cur síos a dhéanamh ar chearta laistigh d'ainmspás;
• ClusterRole - laistigh den bhraisle, lena n-áirítear réada a bhaineann go sonrach le braisle amhail nóid, URLanna neamh-acmhainní (i.e. nach bhfuil baint acu le hacmhainní Kubernetes - mar shampla, /version, /logs, /api*);
• RoleBinding и ClusterRoleBinding - a úsáidtear le haghaidh ceangailteach Role и ClusterRole chuig úsáideoir, grúpa úsáideoirí nó ServiceAccount.

Tá na heintitis Ról agus Rolcheangail teoranta ag ainmspás, i.e. caithfidh sé a bheith laistigh den ainmspás céanna. Mar sin féin, is féidir le RoleBinding tagairt a dhéanamh do ClusterRole, a ligeann duit sraith ceadanna cineálacha a chruthú agus rochtain a rialú agus iad á n-úsáid.

Déanann róil cur síos ar chearta ag baint úsáide as tacair rialacha ina bhfuil:

• Grúpaí API - féach doiciméadú oifigiúil trí apiGrúpaí agus aschur kubectl api-resources;
• acmhainní (acmhainní: pod, namespace, deployment agus mar sin de.);
• Briathra (briathra: set, update agus a leithéidí).
• ainmneacha acmhainne (resourceNames) - cuir i gcás nuair is gá duit rochtain a sholáthar ar acmhainn shonrach, agus ní ar gach acmhainn den chineál seo.

Is féidir anailís níos mionsonraithe ar údarú i Kubernetes a fháil ar an leathanach doiciméadú oifigiúil. Ina áit sin (nó in áit, ina theannta sin), tabharfaidh mé samplaí a léiríonn a cuid oibre.

Samplaí d'eintitis RBAC

Simplí Role, a ligeann duit liosta agus stádas na pods a fháil agus monatóireacht a dhéanamh orthu san ainmspás target-namespace:

apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: target-namespace
  name: pod-reader
rules:
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["get", "watch", "list"]

Sampla ClusterRole, a ligeann duit liosta agus stádas na pods a fháil agus monatóireacht a dhéanamh orthu ar fud an bhraisle:

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  # секции "namespace" нет, так как ClusterRole задействует весь кластер
  name: secret-reader
rules:
- apiGroups: [""]
  resources: ["secrets"]
  verbs: ["get", "watch", "list"]

Sampla RoleBinding, a ligeann don úsáideoir mynewuser pods "léamh" san ainmspás my-namespace:

apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: read-pods
  namespace: target-namespace
subjects:
- kind: User
  name: mynewuser # имя пользователя зависимо от регистра!
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: Role # здесь должно быть “Role” или “ClusterRole”
  name: pod-reader # имя Role, что находится в том же namespace,
                   # или имя ClusterRole, использование которой
                   # хотим разрешить пользователю
  apiGroup: rbac.authorization.k8s.io

Iniúchadh imeachtaí

Go scéimreach, is féidir ailtireacht Kubernetes a léiriú mar seo a leanas:

Is é príomh-chomhpháirt Kubernetes atá freagrach as iarratais a phróiseáil api-freastalaí. Téann gach oibríocht ar an mbraisle tríd. Is féidir leat tuilleadh a léamh faoi na meicníochtaí inmheánacha seo san alt “Cad a tharlaíonn i Kubernetes nuair a ritheann tú kubectl run?'.

Is gné spéisiúil é iniúchadh córais i Kubernetes, atá díchumasaithe de réir réamhshocraithe. Ligeann sé duit gach glao a logáil chuig Kubernetes API. Mar a d’fhéadfá buille faoi thuairim, déantar gach gníomh a bhaineann le monatóireacht agus athrú ar staid an bhraisle tríd an API seo. Is féidir (mar is gnách) cur síos maith ar a chumais a fháil i doiciméadú oifigiúil K8s. Ansin, déanfaidh mé iarracht an topaic a chur i láthair i dteanga níos simplí.

Mar sin, chun iniúchadh a chumasú, ní mór dúinn trí pharaiméadair riachtanacha a chur ar aghaidh chuig an gcoimeádán in api-server, a bhfuil cur síos níos mine orthu thíos:

• --audit-policy-file=/etc/kubernetes/policies/audit-policy.yaml
• --audit-log-path=/var/log/kube-audit/audit.log
• --audit-log-format=json

Chomh maith leis na trí pharaiméadair riachtanacha seo, tá go leor socruithe breise ann a bhaineann le hiniúchadh: ó rothlú log go tuairiscí gréasáin. Sampla de pharaiméadair rothlaithe loga:

• --audit-log-maxbackup=10
• --audit-log-maxsize=100
• --audit-log-maxage=7

Ach ní bheidh muid ag fanacht níos mine orthu - is féidir leat teacht ar na sonraí go léir i doiciméadú kube-apiserver.

Mar a luadh cheana, socraítear na paraiméadair go léir sa léiriú le cumraíocht api-server (de réir réamhshocraithe /etc/kubernetes/manifests/kube-apiserver.yaml), in alt command. Fillfimid ar na 3 pharaiméadair riachtanacha agus déanaimid anailís orthu:

1. audit-policy-file — cosán go dtí an comhad YAML ina ndéantar cur síos ar an mbeartas iniúchóireachta. Fillfimid ar a bhfuil ann níos déanaí, ach faoi láthair tabharfaidh mé faoi deara go gcaithfidh an comhad a bheith inléite ag an bpróiseas api-server. Mar sin, is gá é a shuiteáil taobh istigh den choimeádán, ar féidir leat an cód seo a leanas a chur leis na codanna cuí den chumraíocht:

     volumeMounts:
       - mountPath: /etc/kubernetes/policies
         name: policies
         readOnly: true
     volumes:
     - hostPath:
         path: /etc/kubernetes/policies
         type: DirectoryOrCreate
       name: policies

2. audit-log-path - cosán chuig an logchomhad. Caithfidh an cosán a bheith inrochtana don phróiseas api-server, mar sin déanaimid cur síos ar a fheistiú ar an mbealach céanna:

     volumeMounts:
       - mountPath: /var/log/kube-audit
         name: logs
         readOnly: false
     volumes:
     - hostPath:
         path: /var/log/kube-audit
         type: DirectoryOrCreate
       name: logs

3. audit-log-format — formáid loga iniúchta. Is é an réamhshocrú json, ach tá formáid an téacs oidhreachta ar fáil freisin (legacy).

Beartas Iniúchta

Anois faoin gcomhad luaite ag cur síos ar an bpolasaí logála. Is é an chéad choincheap de bheartas iniúchta level, leibhéal logáil. Tá siad mar seo a leanas:

• None - ná logáil;
• Metadata — meiteashonraí iarratais logála: úsáideoir, am iarratais, acmhainn sprice (pod, ainmspás, etc.), cineál gnímh (briathar), etc.;
• Request — meiteashonraí logála agus comhlacht iarratais;
• RequestResponse — meiteashonraí logála, comhlacht iarratais agus comhlacht freagartha.

An dá leibhéal deiridh (Request и RequestResponse) ná logáil isteach iarrataí nach bhfuair rochtain ar acmhainní (rochtain ar URLanna neamhacmhainní mar a thugtar orthu).

Chomh maith leis sin téann gach iarratas tríd roinnt céimeanna:

• RequestReceived — an chéim ina bhfaighidh an próiseálaí an t-iarratas agus nár tarchuireadh é níos faide feadh an tslabhra próiseálaithe;
• ResponseStarted — seoltar ceanntásca freagartha, ach sula seolfar an comhlacht freagartha. Ginte le haghaidh fiosrúcháin fadtréimhseacha (mar shampla, watch);
• ResponseComplete — go bhfuil an comhlacht freagartha seolta, ní sheolfar a thuilleadh faisnéise;
• Panic — gintear teagmhais nuair a bhraitear staid mhínormálta.

Chun skip aon chéimeanna is féidir leat a úsáid omitStages.

I gcomhad beartais, is féidir linn cur síos a dhéanamh ar chodanna éagsúla le leibhéil éagsúla logáil. Cuirfear an chéad riail mheaitseála a aimsítear sa tuairisc ar an mbeartas i bhfeidhm.

Déanann an deamhan kubelet monatóireacht ar athruithe sa léiriú le cumraíocht an fhreastalaí api agus, má aimsítear aon cheann, atosaíonn sé an coimeádán le freastalaí api. Ach tá sonraí tábhachtacha ann: déanfaidh sé neamhaird de athruithe sa chomhad polasaí. Tar éis duit athruithe a dhéanamh ar an gcomhad polasaí, beidh ort an api-server a atosú de láimh. Ós rud é go gcuirtear tús le api-server mar pod statach, foireann kubectl delete ní chuirfidh sé faoi deara é a atosú. Beidh ort é a dhéanamh de láimh docker stop ar kube-masters, i gcás inar athraíodh an beartas iniúchóireachta:

docker stop $(docker ps | grep k8s_kube-apiserver | awk '{print $1}')

Agus iniúchadh á chumasú, tá sé tábhachtach cuimhneamh air sin méadaíonn an t-ualach ar kube-apiserver. Go háirithe, méadaítear tomhaltas cuimhne chun comhthéacs iarratais a stóráil. Ní thosaíonn an logáil ach amháin tar éis an ceanntásc freagartha a sheoladh. Braitheann an t-ualach freisin ar chumraíocht an bheartais iniúchta.

Samplaí de pholasaithe

Breathnaímid ar struchtúr na gcomhad beartais ag baint úsáide as samplaí.

Seo comhad simplí policygach rud a logáil ar an leibhéal Metadata:

apiVersion: audit.k8s.io/v1
kind: Policy
rules:
- level: Metadata

Sa pholasaí is féidir leat liosta úsáideoirí a shonrú (Users и ServiceAccounts) agus grúpaí úsáideoirí. Mar shampla, is é seo an chaoi a ndéanfaimid neamhaird ar úsáideoirí córais, ach logáil gach rud eile ar an leibhéal Request:

apiVersion: audit.k8s.io/v1
kind: Policy
rules:
  - level: None
    userGroups:
      - "system:serviceaccounts"
      - "system:nodes"
    users:
      - "system:anonymous"
      - "system:apiserver"
      - "system:kube-controller-manager"
      - "system:kube-scheduler"
  - level: Request

Is féidir freisin cur síos a dhéanamh ar na spriocanna:

• spásanna ainmneacha (namespaces);
• Briathra (briathra: get, update, delete agus Daoine eile);
• acmhainní (acmhainní, Mar seo a leanas: pod, configmaps srl.) agus grúpaí acmhainní (apiGroups).

Tabhair aire! Is féidir acmhainní agus grúpaí acmhainní (grúpaí API, i.e. apiGroups), chomh maith lena leaganacha atá suiteáilte sa bhraisle, a fháil trí na horduithe a úsáid:

kubectl api-resources
kubectl api-versions

Cuirtear an beartas iniúchta seo a leanas ar fáil mar léiriú ar dhea-chleachtais i Doiciméid Alibaba Cloud:

apiVersion: audit.k8s.io/v1beta1
kind: Policy
# Не логировать стадию RequestReceived
omitStages:
  - "RequestReceived"
rules:
  # Не логировать события, считающиеся малозначительными и не опасными:
  - level: None
    users: ["system:kube-proxy"]
    verbs: ["watch"]
    resources:
      - group: "" # это api group с пустым именем, к которому относятся
                  # базовые ресурсы Kubernetes, называемые “core”
        resources: ["endpoints", "services"]
  - level: None
    users: ["system:unsecured"]
    namespaces: ["kube-system"]
    verbs: ["get"]
    resources:
      - group: "" # core
        resources: ["configmaps"]
  - level: None
    users: ["kubelet"]
    verbs: ["get"]
    resources:
      - group: "" # core
        resources: ["nodes"]
  - level: None
    userGroups: ["system:nodes"]
    verbs: ["get"]
    resources:
      - group: "" # core
        resources: ["nodes"]
  - level: None
    users:
      - system:kube-controller-manager
      - system:kube-scheduler
      - system:serviceaccount:kube-system:endpoint-controller
    verbs: ["get", "update"]
    namespaces: ["kube-system"]
    resources:
      - group: "" # core
        resources: ["endpoints"]
  - level: None
    users: ["system:apiserver"]
    verbs: ["get"]
    resources:
      - group: "" # core
        resources: ["namespaces"]
  # Не логировать обращения к read-only URLs:
  - level: None
    nonResourceURLs:
      - /healthz*
      - /version
      - /swagger*
  # Не логировать сообщения, относящиеся к типу ресурсов “события”:
  - level: None
    resources:
      - group: "" # core
        resources: ["events"]
  # Ресурсы типа Secret, ConfigMap и TokenReview могут содержать  секретные данные,
  # поэтому логируем только метаданные связанных с ними запросов
  - level: Metadata
    resources:
      - group: "" # core
        resources: ["secrets", "configmaps"]
      - group: authentication.k8s.io
        resources: ["tokenreviews"]
  # Действия типа get, list и watch могут быть ресурсоёмкими; не логируем их
  - level: Request
    verbs: ["get", "list", "watch"]
    resources:
      - group: "" # core
      - group: "admissionregistration.k8s.io"
      - group: "apps"
      - group: "authentication.k8s.io"
      - group: "authorization.k8s.io"
      - group: "autoscaling"
      - group: "batch"
      - group: "certificates.k8s.io"
      - group: "extensions"
      - group: "networking.k8s.io"
      - group: "policy"
      - group: "rbac.authorization.k8s.io"
      - group: "settings.k8s.io"
      - group: "storage.k8s.io"
  # Уровень логирования по умолчанию для стандартных ресурсов API
  - level: RequestResponse
    resources:
      - group: "" # core
      - group: "admissionregistration.k8s.io"
      - group: "apps"
      - group: "authentication.k8s.io"
      - group: "authorization.k8s.io"
      - group: "autoscaling"
      - group: "batch"
      - group: "certificates.k8s.io"
      - group: "extensions"
      - group: "networking.k8s.io"
      - group: "policy"
      - group: "rbac.authorization.k8s.io"
      - group: "settings.k8s.io"
      - group: "storage.k8s.io"
  # Уровень логирования по умолчанию для всех остальных запросов
  - level: Metadata

Sampla maith eile de bheartas iniúchta is ea próifíl a úsáidtear sa GCE.

Chun freagairt go tapa ar imeachtaí iniúchta, is féidir déan cur síos ar chuaille gréasáin. Tá an cheist seo clúdaithe i doiciméadú oifigiúil, fágfaidh mé lasmuigh de scóip an ailt seo é.

Torthaí

Tugann an t-alt forbhreathnú ar mheicníochtaí bunúsacha slándála i mbraislí Kubernetes, a ligeann duit cuntais úsáideora phearsantaithe a chruthú, a gcearta a scaradh, agus a gcuid gníomhartha a thaifeadadh. Tá súil agam go mbeidh sé úsáideach dóibh siúd atá ag tabhairt aghaidh ar cheisteanna den sórt sin go teoiriciúil nó go praiticiúil. Molaim freisin go léann tú liosta na n-ábhar eile ar an ábhar slándála i Kubernetes, a thugtar i “PS” - b’fhéidir ina measc gheobhaidh tú na sonraí riachtanacha ar na fadhbanna a bhaineann leat.

PS

Léigh freisin ar ár mblag:

• «33+ uirlisí slándála Kubernetes";
• «Réamhrá ar Bheartais Líonra Kubernetes do Ghairmithe Slándála";
• «Tuiscint ar RBAC i Kubernetes";
• «9 gCleachtas is Fearr maidir le Slándáil Kubernetes";
• «11 Bealaí chun (Gan) Bheith i d’Íospartach Hack Kubernetes'.

Foinse: will.com