Réamhrá ar Bheartais Líonra Kubernetes do Ghairmithe Slándála

Nóta. aistrigh.: Tá níos mó ná 20 bliain de thaithí ag údar an ailt, Reuven Harrison, i bhforbairt bogearraí, agus inniu tá an CTO agus comhbhunaitheoir Tufin, cuideachta a chruthaíonn réitigh bainistíochta beartais slándála. Cé go mbreathnaíonn sé ar bheartais líonra Kubernetes mar uirlis chumhachtach go leor chun líonra a dheighilt i gcnuasach, creideann sé freisin nach bhfuil siad chomh furasta sin a chur i bhfeidhm go praiticiúil. Tá an t-ábhar seo (go leor toirtiúil) ceaptha chun feasacht speisialtóirí ar an gceist seo a fheabhsú agus chun cabhrú leo na cumraíochtaí riachtanacha a chruthú.

Sa lá atá inniu ann, tá go leor cuideachtaí ag roghnú Kubernetes níos mó chun a n-iarratas a reáchtáil. Tá suim chomh hard sin sna bogearraí seo go bhfuil cuid acu ag glaoch ar Kubernetes “an córas oibriúcháin nua don ionad sonraí.” De réir a chéile, tá Kubernetes (nó k8s) ag tosú ar a bhrath mar chuid ríthábhachtach den ghnó, a éilíonn eagrú próisis ghnó aibí, lena n-áirítear slándáil líonra.

Do ghairmithe slándála a bhfuil mearbhall orthu ag obair le Kubernetes, b'fhéidir gurb é an fíor-nochtadh polasaí réamhshocraithe an ardáin: ceadaigh gach rud.

Cabhróidh an treoir seo leat struchtúr inmheánach na mbeartas líonra a thuiscint; tuiscint a fháil ar an difríocht atá idir iad agus na rialacha maidir le ballaí dóiteáin rialta. Clúdóidh sé freisin roinnt gaistí agus cuirfidh sé moltaí ar fáil chun cabhrú le feidhmchláir ar Kubernetes a dhaingniú.

Polasaithe líonra Kubernetes

Ceadaíonn meicníocht beartais líonra Kubernetes duit idirghníomhaíocht na n-iarratas a imscartar ar an ardán ag an gciseal líonra (an tríú sa tsamhail OSI) a bhainistiú. Tá cuid de na gnéithe casta de bhallaí dóiteáin nua-aimseartha in easnamh ar bheartais líonra, mar fhorfheidhmiú OSI Layer 7 agus braite bagairtí, ach soláthraíonn siad bunleibhéal slándála líonra atá ina phointe tosaigh maith.

Rialaíonn beartais líonra cumarsáid idir pods

Déantar ualaí oibre i Kubernetes a dháileadh ar phodanna, arb é atá iontu coimeádán amháin nó níos mó a imlonnaítear le chéile. Sannann Kubernetes seoladh IP do gach pod atá inrochtana ó phodanna eile. Socraíonn beartais líonra Kubernetes cearta rochtana do ghrúpaí pods ar an mbealach céanna a úsáidtear grúpaí slándála sa scamall chun rochtain ar chásanna meaisíní fíorúla a rialú.

Beartais Líonra a Shainmhíniú

Cosúil le hacmhainní eile Kubernetes, sonraítear beartais líonra in YAML. Sa sampla thíos, an t-iarratas balance rochtain ar postgres:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default.postgres
  namespace: default
spec:
  podSelector:
    matchLabels:
      app: postgres
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: balance
  policyTypes:
  - Ingress

(Nóta. aistrigh.: cruthaíodh an screenshot seo, cosúil le gach ceann dá samhail ina dhiaidh sin, gan úsáid a bhaint as uirlisí dúchais Kubernetes, ach ag baint úsáide as an uirlis Tufin Orca, a d'fhorbair cuideachta údair an ailt bhunaidh agus a luaitear ag deireadh an ábhair.)

Chun do bheartas líonra féin a shainiú, beidh eolas bunúsach ar YAML uait. Tá an teanga seo bunaithe ar eangú (spásanna seachas cluaisíní sonraithe). Baineann eilimint eangaithe leis an eilimint eangaithe is gaire os a chionn. Tosaíonn eilimint liosta nua le fleiscín, tá an fhoirm ag gach eilimint eile eochair-luach.

Tar éis cur síos a dhéanamh ar an mbeartas in YAML, bain úsáid as cubectlchun é a chruthú sa bhraisle:

kubectl create -f policy.yaml

Sonraíocht Beartais Líonra

Áirítear ceithre eilimint i sonraíocht bheartais líonra Kubernetes:

1. podSelector: sainmhíníonn sé na pods tionchar ag an mbeartas seo (spriocanna) - ag teastáil;
2. policyTypes: léiríonn sé na cineálacha polasaithe atá san áireamh anseo: dul isteach agus/nó imeacht - roghnach, ach molaim é a shonrú go sainráite i ngach cás;
3. ingress: sainmhínítear ceadaithe ag teacht isteach trácht chuig pods sprioc - roghnach;
4. egress: sainmhínítear ceadaithe ag dul as oifig tá trácht ó phodanna sprice roghnach.

Sampla tógtha ó shuíomh Gréasáin Kubernetes (chuir mé ionad role ar app), léiríonn sé conas a úsáidtear na ceithre eilimint go léir:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: test-network-policy
  namespace: default
spec:
  podSelector:    # <<<
    matchLabels:
      app: db
  policyTypes:    # <<<
  - Ingress
  - Egress
  ingress:        # <<<
  - from:
    - ipBlock:
        cidr: 172.17.0.0/16
        except:
        - 172.17.1.0/24
    - namespaceSelector:
        matchLabels:
          project: myproject
    - podSelector:
        matchLabels:
          role: frontend
    ports:
    - protocol: TCP
      port: 6379
  egress:         # <<<
  - to:
    - ipBlock:
        cidr: 10.0.0.0/24
    ports:
    - protocol: TCP
      port: 5978

Tabhair faoi deara le do thoil nach gá na ceithre eilimint ar fad a chur san áireamh. Níl sé ach éigeantach podSelector, is féidir paraiméadair eile a úsáid mar atá ag teastáil.

Má fhágann tú ar lár policyTypes, léirmhíneofar an beartas mar seo a leanas:

• De réir réamhshocraithe, glactar leis go sainíonn sé an taobh isteach. Mura ndeirtear é seo go sainráite sa pholasaí, glacfaidh an córas leis go bhfuil cosc ​​ar gach trácht.
• Cinnfear an t-iompar ar an taobh bealach amach trí láithreacht nó easpa na bparaiméadar dul amach comhfhreagrach.

Chun botúin a sheachaint molaim a dhéanamh soiléir i gcónaí policyTypes.

De réir an loighic thuas, má tá na paraiméadair ingress agus / nó egress fágtha ar lár, diúltóidh an polasaí an trácht go léir (féach "Riail Stripping" thíos).

Is é polasaí réamhshocraithe Ceadaigh

Mura ndéantar aon bheartais a shainiú, ceadaíonn Kubernetes an trácht go léir de réir réamhshocraithe. Is féidir le gach pods faisnéis a mhalartú eatarthu féin faoi shaoirse. D’fhéadfadh sé go bhfuil an chuma air nach bhfuil sé seo iomasach ó thaobh na slándála de, ach cuimhnigh gur dhear forbróirí Kubernetes ar dtús chun idir-inoibritheacht feidhmchláir a chumasú. Cuireadh beartais líonra leis níos déanaí.

Ainmspásanna

Is meicníocht comhoibrithe Kubernetes iad spásanna ainmneacha. Tá siad deartha chun timpeallachtaí loighciúla a leithlisiú óna chéile, agus ceadaítear cumarsáid idir spásanna de réir réamhshocraithe.

Cosúil le formhór na gcomhpháirteanna Kubernetes, maireann beartais líonra in ainmspás ar leith. Sa bhloc metadata is féidir leat a shonrú cén spás lena mbaineann an polasaí:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: test-network-policy
  namespace: my-namespace  # <<<
spec:
...

Mura bhfuil an t-ainmspás sonraithe go sainráite sna meiteashonraí, úsáidfidh an córas an t-ainmspás sonraithe i kubectl (de réir réamhshocraithe namespace=default):

kubectl apply -n my-namespace -f namespace.yaml

Molaim sonraigh ainmspás go sainráite, ach amháin má tá tú ag scríobh polasaí a dhíríonn ar spásanna iolracha ag an am céanna.

An príomh eilimint podSelector sa pholasaí roghnóidh sé pods ón ainmspás lena mbaineann an polasaí (diúltaítear rochtain ar phodaí ó ainmspás eile).

Mar an gcéanna, podSelectors i mbloic isteach agus amach ní féidir leo ach pods a roghnú óna n-ainmspás féin, mura rud é, ar ndóigh, go gcomhcheanglaíonn tú iad namespaceSelector (Déanfar é seo a phlé sa rannán “Scag de réir spásanna ainm agus pods”).

Rialacha Ainmnithe Beartais

Tá ainmneacha polasaí uathúil laistigh den ainmspás céanna. Ní féidir dhá pholasaí leis an ainm céanna a bheith sa spás céanna, ach is féidir polasaithe leis an ainm céanna a bheith i spásanna éagsúla. Tá sé seo úsáideach nuair is mian leat an polasaí céanna a chur i bhfeidhm arís thar spásanna iolracha.

Is maith liom go háirithe ceann de na modhanna ainmniúcháin. Is éard atá ann an t-ainm ainmspáis a chomhcheangal leis na spriocphodaí. Mar shampla:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default.postgres  # <<<
  namespace: default
spec:
  podSelector:
    matchLabels:
      app: postgres
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: admin
  policyTypes:
  - Ingress

Lipéid

Is féidir leat lipéid shaincheaptha a cheangal le réada Kubernetes, amhail pods agus spásanna ainmneacha. Lipéid (lipéid - clibeanna) comhionann le clibeanna sa scamall. Úsáideann beartais líonra Kubernetes lipéid chun roghnú podslena mbaineann siad:

podSelector:
  matchLabels:
    role: db

… nó spásanna ainmneachalena mbaineann siad. Roghnaíonn an sampla seo gach pods i spásanna ainm leis na lipéid comhfhreagracha:

namespaceSelector:
  matchLabels:
    project: myproject

Rabhadh amháin: nuair a úsáid namespaceSelector cinntigh go bhfuil an lipéad ceart sna hainmspásanna a roghnaíonn tú. Bí ar an eolas go bhfuil spásanna ainmneacha ionsuite mar default и kube-system, de réir réamhshocraithe nach bhfuil lipéid.

Is féidir leat lipéad a chur le spás mar seo:

kubectl label namespace default namespace=default

Ag an am céanna, ainmspás sa rannóg metadata ba cheart tagairt a dhéanamh don ainm spáis iarbhír, ní don lipéad:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: test-network-policy
  namespace: default   # <<<
spec:
...

Foinse agus ceann scríbe

Is éard atá i mbeartais balla dóiteáin rialacha le foinsí agus cinn scríbe. Sainmhínítear beartais líonra Kubernetes le haghaidh sprice - sraith pods a mbaineann siad leo - agus ansin socraítear rialacha maidir le trácht isteach agus/nó as. Inár sampla, beidh gach pods san ainmspás mar sprioc don pholasaí default le lipéad le heochair app agus brí db:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: test-network-policy
  namespace: default
spec:
  podSelector:
    matchLabels:
      app: db   # <<<
  policyTypes:
  - Ingress
  - Egress
  ingress:
  - from:
    - ipBlock:
        cidr: 172.17.0.0/16
        except:
        - 172.17.1.0/24
    - namespaceSelector:
        matchLabels:
          project: myproject
    - podSelector:
        matchLabels:
          role: frontend
    ports:
    - protocol: TCP
      port: 6379
  egress:
  - to:
    - ipBlock:
        cidr: 10.0.0.0/24
    ports:
    - protocol: TCP
      port: 5978

Foroinn ingress sa bheartas seo, osclaíonn sé trácht ag teacht isteach chuig na pods sprice. I bhfocail eile, is é dul isteach an fhoinse agus is é an sprioc an ceann scríbe comhfhreagrach. Mar an gcéanna, is é an bealach amach an ceann scríbe agus is é an sprioc a fhoinse.

Tá sé seo comhionann le dhá riail balla dóiteáin: Ingress → Target; Sprioc → Éalaigh.

Egress agus DNS (tábhachtach!)

Trí thrácht amach a theorannú, aird ar leith a thabhairt ar DNS - Úsáideann Kubernetes an tseirbhís seo chun seirbhísí a mhapáil chuig seoltaí IP. Mar shampla, ní oibreoidh an polasaí seo a leanas toisc nár cheadaigh tú an t-iarratas balance rochtain a fháil ar DNS:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default.balance
  namespace: default
spec:
  podSelector:
    matchLabels:
      app: balance
  egress:
  - to:
    - podSelector:
        matchLabels:
          app: postgres
  policyTypes:
  - Egress

Is féidir leat é a dheisiú trí rochtain ar an tseirbhís DNS a oscailt:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default.balance
  namespace: default
spec:
  podSelector:
    matchLabels:
      app: balance
  egress:
  - to:
    - podSelector:
        matchLabels:
          app: postgres
  - to:               # <<<
    ports:            # <<<
    - protocol: UDP   # <<<
      port: 53        # <<<
  policyTypes:
  - Egress

Eilimint dheireanach to folamh, agus dá bhrí sin roghnaíonn sé go hindíreach gach pod i ngach ainmspás, ag ligean balance seol ceisteanna DNS chuig an tseirbhís chuí Kubernetes (ag rith sa spás de ghnáth kube-system).

Oibríonn an cur chuige seo, áfach ró-cheadaitheach agus neamhchinnteach, toisc go gceadaíonn sé ceisteanna DNS a dhíriú lasmuigh den bhraisle.

Is féidir leat é a fheabhsú i dtrí chéim as a chéile.

1. Ceadaigh ceisteanna DNS amháin laistigh braisle ag cur namespaceSelector:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default.balance
  namespace: default
spec:
  podSelector:
    matchLabels:
      app: balance
  egress:
  - to:
    - podSelector:
        matchLabels:
          app: postgres
  - to:
    - namespaceSelector: {} # <<<
    ports:
    - protocol: UDP
      port: 53
  policyTypes:
  - Egress

2. Ceadaigh fiosruithe DNS laistigh den ainmspás amháin kube-system.

Chun é seo a dhéanamh ní mór duit lipéad a chur leis an ainmspás kube-system: kubectl label namespace kube-system namespace=kube-system - agus scríobh síos é in úsáid beartais namespaceSelector:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default.balance
  namespace: default
spec:
  podSelector:
    matchLabels:
      app: balance
  egress:
  - to:
    - podSelector:
        matchLabels:
          app: postgres
  - to:
    - namespaceSelector:         # <<<
        matchLabels:             # <<<
          namespace: kube-system # <<<
    ports:
    - protocol: UDP
      port: 53
  policyTypes:
  - Egress

3. Is féidir le daoine paranoid dul níos faide agus ceisteanna DNS a theorannú chuig seirbhís DNS ar leith i kube-system. Inseoidh an rannán “Scag de réir spásanna ainm AGUS pods” duit conas é seo a bhaint amach.

Rogha eile is ea DNS a réiteach ag leibhéal an ainmspáis. Sa chás seo, ní gá é a oscailt do gach seirbhís:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default.dns
  namespace: default
spec:
  podSelector: {} # <<<
  egress:
  - to:
    - namespaceSelector: {}
    ports:
    - protocol: UDP
      port: 53
  policyTypes:
  - Egress

Folamh podSelector roghnaíonn gach pods san ainmspás.

An chéad chluiche agus ord na rialach

I ngnáthbhallaí dóiteáin, déantar an gníomh (Ceadaigh nó Diúltaigh) ar phaicéad a chinneadh ag an gcéad riail a shásaíonn sé. I Kubernetes, ní hionann ord na bpolasaithe.

De réir réamhshocraithe, nuair nach socraítear aon bheartais, ceadaítear cumarsáid idir pods agus is féidir leo faisnéis a mhalartú go saor. Chomh luath agus a thosaíonn tú ag ceapadh polasaithe, déantar gach pod a mbíonn tionchar ag ceann amháin acu ar a laghad orthu a leithlisiú de réir dícheangail (NÓ loighciúil) na mbeartas go léir a roghnaigh é. Fanann pods nach gcuireann aon bheartas isteach orthu ar oscailt.

Is féidir leat an t-iompar seo a athrú trí úsáid a bhaint as riail stripping.

Riail stripping (“Diúltaigh”)

Is gnách go ndiúltaíonn polasaithe balla dóiteáin aon trácht nach gceadaítear go sainráite.

Níl aon ghníomh a shéanadh i Kubernetes, áfach, is féidir éifeacht den chineál céanna a bhaint amach le polasaí rialta (cheadaitheach) trí ghrúpa folamh de phodaí foinse a roghnú (a chur isteach):

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: deny-all
  namespace: default
spec:
  podSelector: {}
  policyTypes:
  - Ingress

Roghnaíonn an polasaí seo na pods go léir san ainmspás agus fágann sé dul isteach neamhshainithe, rud a shéanann gach trácht isteach.

Ar an mbealach céanna, is féidir leat gach trácht amach a shrianadh ó spás ainm:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: deny-all-egress
  namespace: default
spec:
  podSelector: {}
  policyTypes:
  - Egress

Tabhair faoi deara go bhfuil beidh tosaíocht ag aon bheartais bhreise a cheadaíonn do thrácht dul isteach sa spás ainm ar an riail seo (cosúil le riail cheadaithe a chur leis roimh riail séanadh i gcumraíocht balla dóiteáin).

Ceadaigh gach rud (Any-Any-Any-Allow)

Chun polasaí Ceadaigh Uile a chruthú, ní mór duit an polasaí Diúltaigh thuas a fhorlíonadh le heilimint folamh ingress:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-all
  namespace: default
spec:
  podSelector: {}
  ingress: # <<<
  - {}     # <<<
  policyTypes:
  - Ingress

Ligeann sé rochtain ó gach pod i ngach ainmspás (agus gach IP) chuig aon choda san ainmspás default. Tá an t-iompar seo cumasaithe de réir réamhshocraithe, mar sin de ghnáth ní gá é a shainiú tuilleadh. Mar sin féin, uaireanta b'fhéidir go mbeadh ort roinnt ceadanna sonracha a dhíchumasú go sealadach chun an fhadhb a dhiagnóiseadh.

Is féidir an riail a chaolú chun rochtain a cheadú amháin sraith ar leith de pods (app:balance) san ainmspás default:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-all-to-balance
  namespace: default
spec:
  podSelector:
    matchLabels:
      app: balance
  ingress: 
  - {}
  policyTypes:
  - Ingress

Ceadaíonn an polasaí seo a leanas gach trácht isteach agus amach, lena n-áirítear rochtain ar aon IP lasmuigh den bhraisle:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-all
spec:
  podSelector: {}
  ingress:
  - {}
  egress:
  - {}
  policyTypes:
  - Ingress
  - Egress

Polasaithe Iolracha a Chomhcheangal

Cuirtear beartais le chéile trí úsáid a bhaint as NÓ loighciúil ar thrí leibhéal; Socraítear ceadanna gach pod de réir dícheangail gach polasaí a mbíonn tionchar aige air:

1. Sna réimsí from и to Is féidir trí chineál d’eilimintí a shainmhíniú (a chuirtear le chéile iad go léir ag baint úsáide as NÓ):

• namespaceSelector — roghnaíonn an t-ainmspás iomlán;
• podSelector — roghnaíonn pods;
• ipBlock - roghnaíonn folíon.

Thairis sin, líon na n-eilimintí (fiú cinn comhionann) i bhfo-ailt from/to gan a bheith teoranta. Cuirfear gach ceann díobh le chéile ag NÓ loighciúil.

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default.postgres
  namespace: default
spec:
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: indexer
    - podSelector:
        matchLabels:
          app: admin
  podSelector:
    matchLabels:
      app: postgres
  policyTypes:
  - Ingress

2. Laistigh den rannán beartais ingress is féidir go leor gnéithe a bheith ann from (le chéile ag NÓ loighciúil). Mar an gcéanna, alt egress féadfaidh go leor gnéithe a bheith san áireamh to (comhcheangailte freisin trí dhícheangal):

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default.postgres
  namespace: default
spec:
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: indexer
  - from:
    - podSelector:
        matchLabels:
          app: admin
  podSelector:
    matchLabels:
      app: postgres
  policyTypes:
  - Ingress

3. Comhcheanglaítear beartais éagsúla le NÓ loighciúil freisin

Ach nuair a chuirtear le chéile iad, tá teorainn amháin ar a bhfuil chuir sé in iúl Chris Cooney: Ní féidir le Kubernetes ach polasaithe a chomhcheangal le polasaithe éagsúla policyTypes (Ingress nó Egress). Forscríobhfaidh beartais a shainmhíníonn dul isteach (nó bealach amach) a chéile.

Gaol idir spásanna ainmneacha

De réir réamhshocraithe, ceadaítear faisnéis a roinnt idir spásanna ainmneacha. Is féidir é seo a athrú trí úsáid a bhaint as polasaí diúltaithe a chuirfidh srian ar thrácht atá ag imeacht agus/nó ag teacht isteach san ainmspás (féach "Riail Stripping" thuas).

Nuair a bheidh rochtain ar ainmspás bactha agat (féach an "Riail Stripping" thuas), is féidir leat eisceachtaí a dhéanamh ar an bpolasaí séanta trí naisc a cheadú ó ainmspás ar leith a úsáideann namespaceSelector:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: database.postgres
  namespace: database
spec:
  podSelector:
    matchLabels:
      app: postgres
  ingress:
  - from:
    - namespaceSelector: # <<<
        matchLabels:
          namespace: default
  policyTypes:
  - Ingress

Mar thoradh air sin, gach pods san ainmspás default beidh rochtain ar pods postgres in ainmspás database. Ach cad más mian leat rochtain a oscailt ar postgres pods sonracha amháin san ainmspás default?

Scag de réir spásanna ainm agus pods

Ceadaíonn leagan Kubernetes 1.11 agus níos airde duit oibreoirí a chur le chéile namespaceSelector и podSelector ag baint úsáide as loighciúil AGUS Breathnaíonn sé mar seo:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: database.postgres
  namespace: database
spec:
  podSelector:
    matchLabels:
      app: postgres
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          namespace: default
      podSelector: # <<<
        matchLabels:
          app: admin
  policyTypes:
  - Ingress

Cén fáth a ndéantar é seo a léirmhíniú mar AND in ionad an ghnáth NÓ?

tabhair faoi deara go podSelector Ní thosaíonn le fleiscín. In YAML ciallaíonn sé seo go podSelector agus ina sheasamh os a chomhair namespaceSelector déan tagairt don eilimint liosta céanna. Dá bhrí sin, tá siad in éineacht le loighciúil AGUS.

Ag cur fleiscín roimhe seo podSelector mar thoradh air sin go dtiocfaidh eilimint liosta nua chun cinn, a chuirfear le chéile leis an gceann roimhe sin namespaceSelector ag baint úsáide as loighciúil NÓ.

Chun pods a roghnú le lipéad ar leith i ngach ainmspás, cuir isteach bán namespaceSelector:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: database.postgres
  namespace: database
spec:
  podSelector:
    matchLabels:
      app: postgres
  ingress:
  - from:
    - namespaceSelector: {}
      podSelector:
        matchLabels:
          app: admin
  policyTypes:
  - Ingress

Téann lipéid iolracha i gcomhar le I

Cuirtear rialacha maidir le balla dóiteáin le rudaí iolracha (óstaigh, líonraí, grúpaí) le chéile ag baint úsáide as NÓ loighciúil. Oibreoidh an riail seo a leanas má mheaitseálann foinse an phaicéid Host_1 Nó Host_2:

| Source | Destination | Service | Action |
| ----------------------------------------|
| Host_1 | Subnet_A    | HTTPS   | Allow  |
| Host_2 |             |         |        |
| ----------------------------------------|

A mhalairt ar fad, i Kubernetes na lipéid éagsúla i podSelector nó namespaceSelector comhcheangailte le AND loighciúil Mar shampla, roghnóidh an riail seo a leanas pods a bhfuil an dá lipéad orthu, role=db И version=v2:

podSelector:
  matchLabels:
    role: db
    version: v2

Baineann an loighic chéanna le gach cineál oibreoirí: roghnóirí sprice beartais, roghnóirí pods, agus roghnóirí ainmspáis.

Subnets agus seoltaí IP (IPBlocks)

Úsáideann ballaí dóiteáin VLANanna, seoltaí IP, agus folíonta chun líonra a dheighilt.

I Kubernetes, sanntar seoltaí IP go pods go huathoibríoch agus is féidir iad a athrú go minic, mar sin úsáidtear lipéid chun pods agus spásanna ainm a roghnú i mbeartais líonra.

Fo-líonraí (ipBlocks) a úsáidtear nuair a bhíonn naisc sheachtracha (Thuaidh-Theas) ag teacht isteach (ag dul isteach) nó ag dul amach (amach) á mbainistiú. Mar shampla, osclaíonn an polasaí seo do gach pods ón ainmspás default rochtain ar sheirbhís Google DNS:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: egress-dns
  namespace: default
spec:
  podSelector: {}
  policyTypes:
  - Egress
  egress:
  - to:
    - ipBlock:
        cidr: 8.8.8.8/32
    ports:
    - protocol: UDP
      port: 53

Ciallaíonn an roghnóir pod folamh sa sampla seo "roghnaigh gach pod san ainmspás."

Ní cheadaíonn an polasaí seo ach rochtain ar 8.8.8.8; tá cosc ​​ar rochtain ar aon IP eile. Mar sin, go bunúsach, chuir tú bac ar rochtain ar sheirbhís inmheánach Kubernetes DNS. Más mian leat é a oscailt go fóill, cuir é seo in iúl go sainráite.

De ghnáth, ipBlocks и podSelectors atá comheisiatach, ós rud é nach n-úsáidtear seoltaí IP inmheánacha na gcódanna i ipBlocks. Trí léiriú pods IP inmheánacha, ceadóidh tú naisc chuig/ó pods leis na seoltaí seo. Go praiticiúil, ní bheidh a fhios agat cén seoladh IP a úsáidfidh tú, agus sin an fáth nár cheart iad a úsáid chun pods a roghnú.

Mar fhrithshampla, cuimsíonn an beartas seo a leanas gach IP agus dá bhrí sin ceadaíonn sé rochtain ar gach pods eile:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: egress-any
  namespace: default
spec:
  podSelector: {}
  policyTypes:
  - Egress
  egress:
  - to:
    - ipBlock:
        cidr: 0.0.0.0/0

Ní féidir leat rochtain a oscailt ach ar IPanna seachtracha, gan seoltaí IP inmheánacha na pods a áireamh. Mar shampla, más é folíon do phod ná 10.16.0.0/14:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: egress-any
  namespace: default
spec:
  podSelector: {}
  policyTypes:
  - Egress
  egress:
  - to:
    - ipBlock:
        cidr: 0.0.0.0/0
        except:
        - 10.16.0.0/14

Calafoirt agus prótacail

De ghnáth éisteann pods le port amháin. Ciallaíonn sé seo nach féidir leat uimhreacha poirt a shonrú i mbeartais agus gach rud a fhágáil mar réamhshocrú. Mar sin féin, moltar beartais a dhéanamh chomh sriantach agus is féidir, mar sin i gcásanna áirithe is féidir leat calafoirt a shonrú go fóill:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default.postgres
  namespace: default
spec:
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: indexer
    - podSelector:
        matchLabels:
          app: admin
    ports:             # <<<
      - port: 443      # <<<
        protocol: TCP  # <<<
      - port: 80       # <<<
        protocol: TCP  # <<<
  podSelector:
    matchLabels:
      app: postgres
  policyTypes:
  - Ingress

Tabhair faoi deara go bhfuil an roghnóir ports bhaineann le gach eilimint sa bhloc to nó from, ina bhfuil. Chun calafoirt éagsúla a shonrú le haghaidh tacair éagsúla eilimintí, scoilt ingress nó egress i bhfo-ailt éagsúla le to nó from agus do phoirt i ngach clár:

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default.postgres
  namespace: default
spec:
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: indexer
    ports:             # <<<
     - port: 443       # <<<
       protocol: TCP   # <<<
  - from:
    - podSelector:
        matchLabels:
          app: admin
    ports:             # <<<
     - port: 80        # <<<
       protocol: TCP   # <<<
  podSelector:
    matchLabels:
      app: postgres
  policyTypes:
  - Ingress

Oibriú an phoirt réamhshocraithe:

• Má fhágann tú an sainmhíniú ar phoirt ar lár go hiomlán (ports), ciallaíonn sé seo gach prótacal agus gach calafort;
• Má fhágann tú an sainmhíniú prótacail ar lár (protocol), ciallaíonn sé seo TCP;
• Má fhágann tú an sainmhíniú ar phoirt ar lár (port), ciallaíonn sé seo gach calafort.

Cleachtas is fearr: Ná bí ag brath ar luachanna réamhshocraithe, sonraigh na rudaí atá uait go sainráite.

Tabhair faoi deara go gcaithfidh tú poirt pod a úsáid, ní calafoirt seirbhíse (tuilleadh air seo sa chéad mhír eile).

An sainítear polasaithe le haghaidh pods nó seirbhísí?

De ghnáth, cuireann pods i Kubernetes rochtain ar a chéile trí sheirbhís - cothromóir ualaigh fíorúil a atreoraíonn trácht chuig na pods a chuireann an tseirbhís i bhfeidhm. B’fhéidir go gceapfá go rialaíonn beartais líonra rochtain ar sheirbhísí, ach ní hé seo an cás. Oibríonn beartais líonra Kubernetes ar phodphoirt, ní ar chalafoirt seirbhíse.

Mar shampla, má éisteann seirbhís le calafort 80, ach má atreoraíonn sé trácht chuig calafort 8080 dá pods, ní mór duit 8080 go díreach a shonrú sa bheartas líonra.

Ba cheart a mheas go bhfuil a leithéid de mheicníocht fo-optamach: má thagann athrú ar struchtúr inmheánach na seirbhíse (na poirt a éisteann na pods), ní mór na beartais líonra a nuashonrú.

Cur chuige nua ailtireachta ag baint úsáide as Mogall Seirbhíse (mar shampla, féach faoi Istio thíos - approx. transl.) ligeann duit dul i ngleic leis an bhfadhb seo.

An bhfuil sé riachtanach Ingress agus Egress araon a chlárú?

Is é an freagra gairid ná, chun go mbeidh pod A in ann cumarsáid a dhéanamh le pod B, ní mór cead a bheith aige nasc amach a chruthú (le haghaidh seo ní mór duit polasaí bealach amach a chumrú), agus caithfidh pod B a bheith in ann glacadh le nasc isteach ( le haghaidh seo, dá réir sin, is gá duit polasaí ingress).

Mar sin féin, go praiticiúil, is féidir leat brath ar an mbeartas réamhshocraithe chun naisc a cheadú i dtreo amháin nó sa dá threo.

Má tá roinnt pod-fhoinse roghnófar ceann amháin nó níos mó amach-pholaiteoirí, cinnfear na srianta a fhorchuirfear air trína n-aontas. Sa chás seo, beidh ort ceangal leis an pod a cheadú go sainráite -chuig an seolaí. Mura roghnaíonn polasaí ar bith pod, ceadaítear a thrácht amach (amach) de réir réamhshocraithe.

Mar an gcéanna, is é cinniúint an podseolaí, roghnaithe ag ceann amháin nó níos mó ingress-polaiteoirí, a chinneadh ag a n-disaontas. Sa chás seo, ní mór duit ligean dó go sainráite trácht a fháil ón bhfoinse. Mura roghnaíonn polasaí ar bith pod, ceadaítear gach trácht isteach air mar réamhshocrú.

Féach Sonraí nó Gan Stát thíos.

Logs

Ní féidir le polasaithe líonra Kubernetes trácht a logáil. Dá bharr sin bíonn sé deacair a chinneadh an bhfuil polasaí ag oibriú mar a bhí beartaithe agus cuireann sé casta go mór ar anailís slándála.

Rialú tráchta chuig seirbhísí seachtracha

Ní cheadaíonn beartais líonra Kubernetes duit ainm fearainn láncháilithe (DNS) a shonrú i gcodanna egress. Cruthaíonn an fhíric seo míchaoithiúlacht shuntasach nuair a dhéantar iarracht trácht a theorannú chuig cinn scríbe seachtracha nach bhfuil seoladh IP seasta acu (cosúil le aws.com).

Seiceáil Beartais

Tabharfaidh ballaí dóiteáin rabhadh duit nó fiú diúltú glacadh leis an mbeartas mícheart. Déanann Kubernetes roinnt fíoraithe freisin. Agus beartas líonra á shocrú trí kubectl, féadfaidh Kubernetes a dhearbhú go bhfuil sé mícheart agus diúltú glacadh leis. I gcásanna eile, glacfaidh Kubernetes an polasaí agus líonfaidh sé isteach leis na sonraí atá in easnamh. Is féidir iad a fheiceáil ag baint úsáide as an ordú:

kubernetes get networkpolicy <policy-name> -o yaml

Coinnigh i gcuimhne nach bhfuil córas bailíochtaithe Kubernetes dothuigthe agus d'fhéadfadh sé go gcaillfidh sé roinnt cineálacha earráidí.

Fhorghníomhú

Ní chuireann Kubernetes beartais líonra i bhfeidhm é féin, ach níl ann ach tairseach API a tharmligean an t-ualach rialaithe chuig córas bunúsach ar a dtugtar an Comhéadan Líonrú Coimeádán (CNI). Is ionann polasaithe a shocrú ar bhraisle Kubernetes gan an CNI cuí a shannadh agus beartais a chruthú ar fhreastalaí bainistíochta balla dóiteáin gan iad a shuiteáil ar bhallaí dóiteáin ansin. Is fútsa atá sé a chinntiú go bhfuil CNI réasúnta agat nó, i gcás ardáin Kubernetes, á óstáil sa scamall (Is féidir leat liosta na soláthraithe a fheiceáil anseo — thart. tras.), cumasaigh polasaithe líonra a shocróidh CNI duit.

Tabhair faoi deara nach dtabharfaidh Kubernetes rabhadh duit má shocraíonn tú polasaí líonra gan an cúntóir cuí CNI.

Stát nó Gan Stát?

Tá gach CNI Kubernetes ar casadh orm státmhar (mar shampla, úsáideann Calico Linux conntrack). Ligeann sé seo don phoda freagraí a fháil ar an nasc TCP a thionscain sé gan a bheith air é a athbhunú. Mar sin féin, níl mé ar an eolas faoi chaighdeán Kubernetes a ráthódh staidiúlacht.

Ardbhainistíocht Beartais Slándála

Seo roinnt bealaí chun forfheidhmiú an bheartais slándála a fheabhsú in Kubernetes:

1. Úsáideann patrún ailtireachta na Mogall Seirbhíse coimeádáin taobhcharr chun teiliméadracht mhionsonraithe agus rialú tráchta a sholáthar ag an leibhéal seirbhíse. Mar shampla is féidir linn a ghlacadh Istio.
2. Tá cuid de na díoltóirí CNI tar éis a n-uirlisí a leathnú chun dul níos faide ná beartais líonra Kubernetes.
3. Tufin Orca Soláthraíonn infheictheacht agus uathoibriú na mbeartas líonra Kubernetes....

Bainistíonn pacáiste Tufin Orca polasaithe líonra Kubernetes (agus is é foinse na screenshots thuas).

faisnéis bhreise

• Samplaí de bheartais líonra arna n-ullmhú ag Ahmet Alp Balkan ó GKE;
• Doiciméadú ó Kubernetes láithreán gréasáin oifigiúil;
• Treoir maidir le Múnla Líonrú Kubernetes;
• Script le haghaidh seiceáil polasaithe líonra.

Conclúid

Tairgeann beartais líonra Kubernetes sraith mhaith uirlisí chun braislí a dheighilt, ach níl siad iomasach agus tá go leor subtleties acu. Mar gheall ar an gcastacht seo, creidim gur fabhtanna iad go leor de na cnuasbheartais atá ann cheana féin. I measc na réitigh a d’fhéadfaí a dhéanamh ar an bhfadhb seo tá sainmhínithe beartais a uathoibriú nó uirlisí deighilte eile a úsáid.

Tá súil agam go gcabhróidh an treoir seo le roinnt ceisteanna a réiteach agus ceisteanna a d’fhéadfadh teacht ort a réiteach.

PS ó aistritheoir

Léigh freisin ar ár mblag:

• "Ar ais go microservices le Istio": Cuid 1 (réamhrá ar na príomhghnéithe), Cuid 2 (ródú, rialú tráchta), cuid 3 (slándáil);
• "Treoir Léirithe maidir le Líonrú i Kubernetes": páirteanna 1 agus 2 (múnla líonra, líonraí forleagan), Cuid 3 (seirbhísí agus próiseáil tráchta);
• «Docker agus Kubernetes i dtimpeallachtaí slándála-íogair";
• «9 gCleachtas is Fearr maidir le Slándáil Kubernetes";
• «11 Bealaí chun (Gan) Bheith i d’Íospartach Hack Kubernetes'.

Foinse: will.com