Nodyn. traws.: Mae gan awdur yr erthygl, Reuven Harrison, dros 20 mlynedd o brofiad mewn datblygu meddalwedd, a heddiw yw'r CTO a chyd-sylfaenydd Tufin, cwmni sy'n creu atebion rheoli polisi diogelwch. Er ei fod yn ystyried polisïau rhwydwaith Kubernetes fel arf eithaf pwerus ar gyfer segmentu rhwydwaith mewn clwstwr, mae hefyd yn credu nad ydynt mor hawdd i'w gweithredu'n ymarferol. Bwriad y deunydd hwn (eithaf swmpus) yw gwella ymwybyddiaeth arbenigwyr o'r mater hwn a'u helpu i greu'r cyfluniadau angenrheidiol.
Heddiw, mae llawer o gwmnïau'n dewis Kubernetes fwyfwy i redeg eu ceisiadau. Mae diddordeb yn y feddalwedd hon mor uchel nes bod rhai yn galw Kubernetes yn “system weithredu newydd y ganolfan ddata.” Yn raddol, mae Kubernetes (neu k8s) yn dechrau cael ei ystyried yn rhan hanfodol o'r busnes, sy'n gofyn am drefnu prosesau busnes aeddfed, gan gynnwys diogelwch rhwydwaith.
Ar gyfer gweithwyr diogelwch proffesiynol sy'n cael eu drysu gan weithio gyda Kubernetes, efallai mai'r datguddiad go iawn yw polisi diofyn y platfform: caniatewch bopeth.
Bydd y canllaw hwn yn eich helpu i ddeall strwythur mewnol polisïau rhwydwaith; deall sut maen nhw'n wahanol i'r rheolau ar gyfer waliau tân arferol. Bydd hefyd yn ymdrin â rhai peryglon ac yn darparu argymhellion i helpu i sicrhau ceisiadau ar Kubernetes.
Polisïau rhwydwaith Kubernetes
Mae mecanwaith polisi rhwydwaith Kubernetes yn caniatáu ichi reoli rhyngweithio cymwysiadau a ddefnyddir ar y platfform ar haen y rhwydwaith (y trydydd yn y model OSI). Nid oes gan bolisïau rhwydwaith rai o nodweddion uwch waliau tân modern, megis gorfodi a chanfod bygythiadau Haen 7 OSI, ond maent yn darparu lefel sylfaenol o ddiogelwch rhwydwaith sy'n fan cychwyn da.
Mae polisïau rhwydwaith yn rheoli cyfathrebu rhwng codennau
Mae llwythi gwaith yn Kubernetes yn cael eu dosbarthu ar draws codennau, sy'n cynnwys un neu fwy o gynwysyddion wedi'u lleoli gyda'i gilydd. Mae Kubernetes yn rhoi cyfeiriad IP i bob pod sy'n hygyrch o godennau eraill. Mae polisïau rhwydwaith Kubernetes yn gosod hawliau mynediad ar gyfer grwpiau o godennau yn yr un modd ag y mae grwpiau diogelwch yn y cwmwl yn cael eu defnyddio i reoli mynediad i achosion o beiriannau rhithwir.
Diffinio Polisïau Rhwydwaith
Fel adnoddau Kubernetes eraill, nodir polisïau rhwydwaith yn YAML. Yn yr enghraifft isod, y cais balance mynediad i 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
(Nodyn. traws.: crëwyd y sgrin hon, fel pob un tebyg dilynol, nid gan ddefnyddio offer Kubernetes brodorol, ond gan ddefnyddio offeryn Tufin Orca, a ddatblygwyd gan gwmni awdur yr erthygl wreiddiol ac a grybwyllir ar ddiwedd y deunydd.)
I ddiffinio eich polisi rhwydwaith eich hun, bydd angen gwybodaeth sylfaenol arnoch am YAML. Mae'r iaith hon yn seiliedig ar fewnoliad (a bennir gan fylchau yn hytrach na thabiau). Mae elfen wedi'i hindentio yn perthyn i'r elfen wedi'i hindentio agosaf uwch ei ben. Mae elfen rhestr newydd yn dechrau gyda chysylltnod, mae gan bob elfen arall y ffurf gwerth allweddol.
Ar ôl disgrifio'r polisi yn YAML, defnyddiwch i'w greu yn y clwstwr:
kubectl create -f policy.yamlManyleb Polisi Rhwydwaith
Mae manyleb polisi rhwydwaith Kubernetes yn cynnwys pedair elfen:
-
podSelector: yn diffinio’r codennau yr effeithir arnynt gan y polisi hwn (targedau) - gofynnol; -
policyTypes: yn nodi pa fathau o bolisïau sy'n cael eu cynnwys yn hyn: ingress and/or egress - dewisol, ond argymhellaf ei nodi'n benodol ym mhob achos; -
ingress: yn diffinio a ganiateir yn dod i mewn traffig i godennau targed - dewisol; -
egress: yn diffinio a ganiateir allblyg mae traffig o godennau targed yn ddewisol.
Enghraifft a gymerwyd o wefan Kubernetes (roeddwn yn cymryd ei le role ar app), yn dangos sut mae pob un o’r pedair elfen yn cael eu defnyddio:
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
Sylwch nad oes rhaid cynnwys y pedair elfen. Mae'n orfodol yn unig podSelector, gellir defnyddio paramedrau eraill fel y dymunir.
Os ydym yn hepgor policyTypes, caiff y polisi ei ddehongli fel a ganlyn:
- Yn ddiofyn, rhagdybir ei fod yn diffinio'r ochr mynediad. Os nad yw'r polisi'n datgan hyn yn benodol, bydd y system yn cymryd yn ganiataol bod yr holl draffig wedi'i wahardd.
- Bydd yr ymddygiad ar yr ochr allanfa yn cael ei bennu gan bresenoldeb neu absenoldeb y paramedr allanfa cyfatebol.
Er mwyn osgoi camgymeriadau rwy'n argymell ei wneud yn eglur bob amser policyTypes.
Yn ôl y rhesymeg uchod, os yw'r paramedrau ingress a / neu egress wedi'i hepgor, bydd y polisi'n gwadu pob traffig (gweler "Rheol Stripping" isod).
Y polisi diofyn yw Caniatáu
Os na ddiffinnir unrhyw bolisïau, mae Kubernetes yn caniatáu'r holl draffig yn ddiofyn. Gall pob cod gyfnewid gwybodaeth ymhlith ei gilydd yn rhydd. Gall hyn ymddangos yn wrthreddfol o safbwynt diogelwch, ond cofiwch fod Kubernetes wedi'i ddylunio'n wreiddiol gan ddatblygwyr i alluogi rhyngweithrededd cymwysiadau. Ychwanegwyd polisïau rhwydwaith yn ddiweddarach.
Gofodau Enw
Mannau enwau yw mecanwaith cydweithredu Kubernetes. Maent wedi'u cynllunio i ynysu amgylcheddau rhesymegol oddi wrth ei gilydd, tra bod cyfathrebu rhwng gofodau yn cael ei ganiatáu yn ddiofyn.
Fel y rhan fwyaf o gydrannau Kubernetes, mae polisïau rhwydwaith yn byw mewn gofod enw penodol. Yn y bloc metadata gallwch nodi i ba le y mae'r polisi yn perthyn:
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: test-network-policy
namespace: my-namespace # <<<
spec:
...
Os nad yw'r gofod enw wedi'i nodi'n benodol yn y metadata, bydd y system yn defnyddio'r gofod enw a nodir yn kubectl (yn ddiofyn namespace=default):
kubectl apply -n my-namespace -f namespace.yamlRwy'n argymell nodi gofod enw yn benodol, oni bai eich bod yn ysgrifennu polisi sy'n targedu gofodau enwau lluosog ar unwaith.
Y prif elfen podSelector yn y polisi bydd yn dewis codennau o'r gofod enw y mae'r polisi yn perthyn iddo (ni chaniateir mynediad i godennau o ofod enw arall).
Yn yr un modd, podSelectors mewn blociau mynediad ac allan dim ond codennau o'u gofod enw eu hunain y gallant eu dewis, oni bai wrth gwrs eich bod yn eu cyfuno â nhw namespaceSelector (trafodir hyn yn yr adran “Hidlo yn ôl bylchau enwau a chodau”).
Rheolau Enwi Polisi
Mae enwau polisi yn unigryw o fewn yr un gofod enwau. Ni all fod dau bolisi gyda'r un enw yn yr un gofod, ond gall fod polisïau gyda'r un enw mewn bylchau gwahanol. Mae hyn yn ddefnyddiol pan fyddwch am ailgymhwyso'r un polisi ar draws nifer o fannau.
Rwy'n hoff iawn o un o'r dulliau enwi. Mae'n cynnwys cyfuno'r enw gofod enw gyda'r codennau targed. Er enghraifft:
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
Labelau
Gallwch atodi labeli personol i wrthrychau Kubernetes, megis codennau a gofodau enwau. Labelau (labeli - tagiau) yn cyfateb i dagiau yn y cwmwl. Mae polisïau rhwydwaith Kubernetes yn defnyddio labeli i ddewis codennauy maent yn berthnasol iddynt:
podSelector:
matchLabels:
role: db… neu gofodau enwauy maent yn berthnasol iddynt. Mae'r enghraifft hon yn dewis pob cod mewn gofodau enw gyda'r labeli cyfatebol:
namespaceSelector:
matchLabels:
project: myproject
Un rhybudd: wrth ddefnyddio namespaceSelector gwnewch yn siŵr bod y bylchau enw a ddewiswch yn cynnwys y label cywir. Byddwch yn ymwybodol bod gofodau enwau adeiledig fel default и kube-system, yn ddiofyn nid ydynt yn cynnwys labeli.
Gallwch ychwanegu label at ofod fel hyn:
kubectl label namespace default namespace=default
Ar yr un pryd, gofod enwau yn yr adran metadata dylai gyfeirio at yr enw gofod gwirioneddol, nid y label:
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: test-network-policy
namespace: default # <<<
spec:
...Ffynhonnell a chyrchfan
Mae polisïau mur gwarchod yn cynnwys rheolau gyda ffynonellau a chyrchfannau. Diffinnir polisïau rhwydwaith Kubernetes ar gyfer targed - set o godennau y maent yn berthnasol iddynt - ac yna gosodir rheolau ar gyfer traffig sy'n dod i mewn a/neu'n gadael. Yn ein hesiampl ni, targed y polisi fydd pob cod yn y gofod enwau default gyda label gydag allwedd app ac ystyr 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
Is-adran ingress yn y polisi hwn, yn agor traffig sy'n dod i mewn i'r codennau targed. Mewn geiriau eraill, mynediad yw'r ffynhonnell a tharged yw'r cyrchfan cyfatebol. Yn yr un modd, allanfa yw'r cyrchfan a tharged yw ei ffynhonnell.
Mae hyn yn cyfateb i ddwy reol wal dân: Ingress → Target; Gôl → Ymadael.
Egress a DNS (pwysig!)
Trwy gyfyngu ar draffig sy'n mynd allan, rhowch sylw arbennig i DNS - Mae Kubernetes yn defnyddio'r gwasanaeth hwn i fapio gwasanaethau i gyfeiriadau IP. Er enghraifft, ni fydd y polisi canlynol yn gweithio oherwydd nad ydych wedi caniatáu'r cais balance mynediad 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
Gallwch ei drwsio trwy agor mynediad i'r gwasanaeth 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
- to: # <<<
ports: # <<<
- protocol: UDP # <<<
port: 53 # <<<
policyTypes:
- Egress
Elfen olaf to yn wag, ac felly mae'n dewis anuniongyrchol pob cod ym mhob gofod enw, caniatáu balance anfon ymholiadau DNS i'r gwasanaeth Kubernetes priodol (yn rhedeg yn y gofod fel arfer kube-system).
Mae'r dull hwn yn gweithio, sut bynnag y mae rhy ganiataol ac ansicr, oherwydd ei fod yn caniatáu i ymholiadau DNS gael eu cyfeirio y tu allan i'r clwstwr.
Gallwch ei wella mewn tri cham olynol.
1. Caniatáu ymholiadau DNS yn unig y tu mewn clwstwr trwy ychwanegu 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. Caniatáu ymholiadau DNS o fewn namespace yn unig kube-system.
I wneud hyn mae angen i chi ychwanegu label i'r gofod enw kube-system: kubectl label namespace kube-system namespace=kube-system - a'i ysgrifennu i lawr wrth ddefnyddio polisi 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. Gall pobl paranoid fynd hyd yn oed ymhellach a chyfyngu ymholiadau DNS i wasanaeth DNS penodol yn kube-system. Bydd yr adran “Hidlo yn ôl gofodau enwau A chodau” yn dweud wrthych sut i gyflawni hyn.
Opsiwn arall yw datrys DNS ar lefel gofod enw. Yn yr achos hwn, ni fydd angen ei agor ar gyfer pob gwasanaeth:
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
Gwag podSelector yn dewis pob cod yn y gofod enw.
Gêm gyntaf a threfn rheolau
Mewn waliau tân confensiynol, mae'r weithred (Caniatáu neu Wrthod) ar becyn yn cael ei bennu gan y rheol gyntaf y mae'n ei bodloni. Yn Kubernetes, nid yw trefn polisïau o bwys.
Yn ddiofyn, pan na osodir polisïau, caniateir cyfathrebu rhwng codennau a gallant gyfnewid gwybodaeth yn rhydd. Unwaith y byddwch yn dechrau llunio polisïau, bydd pob pod y mae o leiaf un ohonynt yn effeithio arno yn cael ei ynysu yn unol â datgysylltiad (NEU resymegol) yr holl bolisïau a'i dewisodd. Mae codennau nad ydynt yn cael eu heffeithio gan unrhyw bolisi yn parhau ar agor.
Gallwch newid yr ymddygiad hwn gan ddefnyddio rheol stripio.
Rheol stripio (“Gwadu”)
Mae polisïau mur gwarchod fel arfer yn gwadu unrhyw draffig na chaniateir yn benodol.
Nid oes unrhyw wadu gweithredu yn Kubernetes, fodd bynnag, gellir cyflawni effaith debyg gyda pholisi rheolaidd (caniataol) trwy ddewis grŵp gwag o godennau ffynhonnell (mynd i mewn):
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: deny-all
namespace: default
spec:
podSelector: {}
policyTypes:
- Ingress
Mae'r polisi hwn yn dewis pob cod yn y gofod enw ac yn gadael mynediad heb ei ddiffinio, gan atal yr holl draffig sy'n dod i mewn.
Yn yr un modd, gallwch gyfyngu ar yr holl draffig sy'n mynd allan o ofod enw:
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: deny-all-egress
namespace: default
spec:
podSelector: {}
policyTypes:
- Egress
Nodwch hynny bydd unrhyw bolisïau ychwanegol sy'n caniatáu traffig i godennau yn y gofod enwau yn cael blaenoriaeth dros y rheol hon (yn debyg i ychwanegu rheol caniatáu cyn rheol gwadu mewn ffurfweddiad wal dân).
Caniatáu popeth (Unrhyw-unrhyw-unrhyw-ganiatáu)
I greu polisi Caniatáu Pawb, mae angen i chi ychwanegu elfen wag at y polisi Gwrthod uchod ingress:
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-all
namespace: default
spec:
podSelector: {}
ingress: # <<<
- {} # <<<
policyTypes:
- Ingress
Mae'n caniatáu mynediad o pob cod ym mhob gofod enw (a phob IP) i unrhyw god yn y gofod enw default. Mae'r ymddygiad hwn wedi'i alluogi yn ddiofyn, felly nid oes angen ei ddiffinio ymhellach fel arfer. Fodd bynnag, weithiau efallai y bydd angen i chi analluogi rhai caniatâd penodol dros dro i wneud diagnosis o'r broblem.
Gellir culhau'r rheol i ganiatáu mynediad yn unig i set benodol o godennau (app:balance) yn y gofod enw default:
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-all-to-balance
namespace: default
spec:
podSelector:
matchLabels:
app: balance
ingress:
- {}
policyTypes:
- Ingress
Mae’r polisi canlynol yn caniatáu pob traffig sy’n mynd i mewn ac allan, gan gynnwys mynediad i unrhyw eiddo deallusol y tu allan i’r clwstwr:
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-all
spec:
podSelector: {}
ingress:
- {}
egress:
- {}
policyTypes:
- Ingress
- Egress
Cyfuno Polisïau Lluosog
Cyfunir polisïau gan ddefnyddio NEU resymegol ar dair lefel; Mae caniatâd pob pod yn cael ei osod yn unol â datgysylltiad yr holl bolisïau sy’n effeithio arno:
1. Yn y meusydd from и to Gellir diffinio tri math o elfen (mae pob un ohonynt yn cael eu cyfuno gan ddefnyddio OR):
-
namespaceSelector— yn dewis y gofod enw cyfan; -
podSelector- dewis codennau; -
ipBlock— yn dewis is-rwydwaith.
Ar ben hynny, mae nifer yr elfennau (hyd yn oed rhai union yr un fath) mewn is-adrannau from/to heb fod yn gyfyngedig. Bydd pob un ohonynt yn cael eu cyfuno gan OR rhesymegol.
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. Y tu mewn i'r adran bolisi ingress gall fod â llawer o elfennau from (wedi'i gyfuno gan OR rhesymegol). Yn yr un modd, adran egress gall gynnwys llawer o elfennau to (hefyd wedi'i gyfuno trwy ddatgysylltiad):
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. Mae polisïau gwahanol hefyd yn cael eu cyfuno â NEU rhesymegol
Ond wrth eu cyfuno, mae un cyfyngiad ar ba un : Dim ond gyda gwahanol bolisïau y gall Kubernetes gyfuno policyTypes (Ingress neu Egress). Bydd polisïau sy'n diffinio mynediad (neu allanfa) yn trosysgrifo ei gilydd.
Perthynas rhwng gofodau enwau
Yn ddiofyn, caniateir rhannu gwybodaeth rhwng gofodau enwau. Gellir newid hyn drwy ddefnyddio polisi gwadu a fydd yn cyfyngu ar draffig sy'n mynd allan a/neu'n dod i mewn i'r gofod enw (gweler "Rheol Stripping" uchod).
Unwaith y byddwch wedi rhwystro mynediad i ofod enw (gweler y "Rheol Tynnu" uchod), gallwch wneud eithriadau i'r polisi gwadu trwy ganiatáu cysylltiadau o ofod enw penodol gan ddefnyddio 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
O ganlyniad, mae pob codennau yn y gofod enw default yn cael mynediad i godennau postgres mewn gofod enwau database. Ond beth os ydych chi am agor mynediad i postgres dim ond codennau penodol yn y gofod enw default?
Hidlo yn ôl bylchau enwau a chodau
Mae fersiwn Kubernetes 1.11 ac uwch yn caniatáu ichi gyfuno gweithredwyr namespaceSelector и podSelector gan ddefnyddio AC rhesymegol Mae'n edrych fel hyn:
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
Pam mae hwn yn cael ei ddehongli fel AC yn lle'r NEU arferol?
nodi hynny podSelector nid yw'n dechrau gyda chysylltnod. Yn YAML mae hyn yn golygu hynny podSelector ac yn sefyll o'i flaen namespaceSelector cyfeiriwch at yr un elfen rhestr. Felly, maent yn cael eu cyfuno ag AC rhesymegol.
Ychwanegu cysylltnod o'r blaen podSelector yn arwain at ymddangosiad elfen rhestr newydd, a fydd yn cael ei chyfuno â'r un flaenorol namespaceSelector gan ddefnyddio OR rhesymegol.
I ddewis codennau gyda label penodol ym mhob gofod enw, nodwch yn wag 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
Mae labeli lluosog yn ymuno ag I
Mae rheolau ar gyfer wal dân gyda gwrthrychau lluosog (gwestewyr, rhwydweithiau, grwpiau) yn cael eu cyfuno gan ddefnyddio OR rhesymegol. Bydd y rheol ganlynol yn gweithio os yw ffynhonnell y pecyn yn cyfateb Host_1 NEU Host_2:
| Source | Destination | Service | Action |
| ----------------------------------------|
| Host_1 | Subnet_A | HTTPS | Allow |
| Host_2 | | | |
| ----------------------------------------|
I'r gwrthwyneb, yn Kubernetes y labeli amrywiol yn podSelector neu namespaceSelector yn cael eu cyfuno ag AND rhesymegol. Er enghraifft, bydd y rheol ganlynol yn dewis codennau sydd â'r ddau label, role=db И version=v2:
podSelector:
matchLabels:
role: db
version: v2Mae'r un rhesymeg yn berthnasol i bob math o weithredwyr: detholwyr targed polisi, dewiswyr codennau, a dewiswyr gofod enwau.
Is-rwydweithiau a chyfeiriadau IP (IPBlocks)
Mae waliau tân yn defnyddio VLANs, cyfeiriadau IP, ac is-rwydweithiau i segmentu rhwydwaith.
Yn Kubernetes, mae cyfeiriadau IP yn cael eu neilltuo i godiau yn awtomatig a gallant newid yn aml, felly defnyddir labeli i ddewis codennau a gofodau enwau mewn polisïau rhwydwaith.
Is-rwydweithiau (ipBlocks) yn cael eu defnyddio wrth reoli cysylltiadau sy'n dod i mewn (i mewn) neu'n mynd allan (allan) allanol (Gogledd-De). Er enghraifft, mae'r polisi hwn yn agored i bob cod o'r gofod enwau default mynediad i wasanaeth DNS Google:
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
Mae'r dewisydd codennau gwag yn yr enghraifft hon yn golygu "dewiswch bob cod yn y gofod enw."
Mae'r polisi hwn yn caniatáu mynediad i 8.8.8.8 yn unig; gwaherddir mynediad i unrhyw eiddo deallusol arall. Felly, yn y bôn, rydych chi wedi rhwystro mynediad i wasanaeth DNS mewnol Kubernetes. Os ydych chi am ei agor o hyd, nodwch hyn yn benodol.
Fel arfer ipBlocks и podSelectors yn annibynnol ar ei gilydd, gan na ddefnyddir cyfeiriadau IP mewnol codennau ipBlocks. Trwy nodi codennau IP mewnol, byddwch mewn gwirionedd yn caniatáu cysylltiadau i/o godennau gyda'r cyfeiriadau hyn. Yn ymarferol, ni fyddwch yn gwybod pa gyfeiriad IP i'w ddefnyddio, a dyna pam na ddylid eu defnyddio i ddewis codennau.
Fel gwrth-enghraifft, mae'r polisi canlynol yn cynnwys pob IP ac felly'n caniatáu mynediad i bob cod arall:
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
Gallwch agor mynediad i IPs allanol yn unig, heb gynnwys cyfeiriadau IP mewnol codennau. Er enghraifft, os yw is-rwydwaith eich pod yn 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
Porthladdoedd a phrotocolau
Yn nodweddiadol mae codennau'n gwrando ar un porthladd. Mae hyn yn golygu na allwch nodi rhifau porthladdoedd mewn polisïau a gadael popeth fel rhagosodiad. Fodd bynnag, argymhellir gwneud polisïau mor gyfyngol â phosibl, felly mewn rhai achosion gallwch barhau i nodi porthladdoedd:
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
Sylwch fod y dewiswr ports yn berthnasol i bob elfen yn y bloc to neu from, sy'n cynnwys. I nodi gwahanol borthladdoedd ar gyfer gwahanol setiau o elfennau, rhannwch ingress neu egress i mewn i sawl isadran gyda to neu from ac ym mhob cofrestr eich porthladdoedd:
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
Gweithrediad porthladd diofyn:
- Os ydych yn hepgor diffiniad y porthladd yn gyfan gwbl (
ports), mae hyn yn golygu pob protocol a phob porthladd; - Os byddwch yn hepgor diffiniad y protocol (
protocol), mae hyn yn golygu TCP; - Os ydych yn hepgor y diffiniad porthladd (
port), mae hyn yn golygu pob porthladd.
Arfer gorau: Peidiwch â dibynnu ar werthoedd rhagosodedig, nodwch yr hyn sydd ei angen arnoch yn benodol.
Sylwch fod yn rhaid i chi ddefnyddio porthladdoedd pod, nid porthladdoedd gwasanaeth (mwy am hyn yn y paragraff nesaf).
A yw polisïau wedi'u diffinio ar gyfer codennau neu wasanaethau?
Yn nodweddiadol, mae codennau yn Kubernetes yn cyrchu ei gilydd trwy wasanaeth - cydbwysydd llwyth rhithwir sy'n ailgyfeirio traffig i'r codennau sy'n gweithredu'r gwasanaeth. Efallai eich bod yn meddwl bod polisïau rhwydwaith yn rheoli mynediad i wasanaethau, ond nid yw hyn yn wir. Mae polisïau rhwydwaith Kubernetes yn gweithio ar borthladdoedd pod, nid porthladdoedd gwasanaeth.
Er enghraifft, os yw gwasanaeth yn gwrando ar borthladd 80, ond yn ailgyfeirio traffig i borthladd 8080 o'i godennau, rhaid i chi nodi'n union 8080 yn y polisi rhwydwaith.
Dylid ystyried mecanwaith o'r fath yn is-optimaidd: os bydd strwythur mewnol y gwasanaeth (y porthladdoedd y mae codennau'n gwrando arnynt) yn newid, bydd yn rhaid diweddaru polisïau rhwydwaith.
Dull pensaernïol newydd gan ddefnyddio Service Mesh (er enghraifft, gweler am Istio isod - tua. transl.) yn eich galluogi i ymdopi â'r broblem hon.
A oes angen cofrestru Ingress ac Egress?
Yr ateb byr yw ydy, er mwyn i pod A gyfathrebu â pod B, rhaid caniatáu iddo greu cysylltiad sy'n mynd allan (ar gyfer hyn mae angen i chi ffurfweddu polisi allanfa), a rhaid i pod B allu derbyn cysylltiad sy'n dod i mewn ( ar gyfer hyn, yn unol â hynny, mae angen polisi ingress).
Fodd bynnag, yn ymarferol, gallwch ddibynnu ar y polisi rhagosodedig i ganiatáu cysylltiadau i un cyfeiriad neu'r ddau.
Os oes rhai pod-ffynhonnell yn cael ei ddewis gan un neu fwy allanfa-wleidyddion, bydd y cyfyngiadau a osodir arno yn cael eu pennu gan eu datgysylltiad. Yn yr achos hwn, bydd angen i chi ganiatáu cysylltiad â'r pod yn benodol -cyfeiriwr. Os nad yw pod yn cael ei ddewis gan unrhyw bolisi, caniateir ei draffig sy'n mynd allan (allan) yn ddiofyn.
Yn yr un modd, mae tynged y codderbyniwr, wedi'i ddewis gan un neu fwy dod i mewn-politicians, yn cael ei benderfynu gan eu datgysylltiad. Yn yr achos hwn, rhaid i chi ganiatáu yn benodol iddo dderbyn traffig o'r pod ffynhonnell. Os na chaiff pod ei ddewis gan unrhyw bolisi, caniateir yr holl draffig sy'n dod i mewn ar ei gyfer yn ddiofyn.
Gweler Gwladol neu Ddi-wladwriaeth isod.
Logiau
Ni all polisïau rhwydwaith Kubernetes logio traffig. Mae hyn yn ei gwneud hi'n anodd penderfynu a yw polisi'n gweithio yn ôl y bwriad ac yn cymhlethu dadansoddiad diogelwch yn fawr.
Rheoli traffig i wasanaethau allanol
Nid yw polisïau rhwydwaith Kubernetes yn caniatáu ichi nodi enw parth cwbl gymwys (DNS) yn yr adrannau allanfa. Mae'r ffaith hon yn arwain at anghyfleustra sylweddol wrth geisio cyfyngu traffig i gyrchfannau allanol nad oes ganddynt gyfeiriad IP sefydlog (fel aws.com).
Gwiriad Polisi
Bydd waliau tân yn eich rhybuddio neu hyd yn oed yn gwrthod derbyn y polisi anghywir. Mae Kubernetes hefyd yn gwneud rhywfaint o ddilysu. Wrth osod polisi rhwydwaith trwy kubectl, gall Kubernetes ddatgan ei fod yn anghywir a gwrthod ei dderbyn. Mewn achosion eraill, bydd Kubernetes yn cymryd y polisi ac yn ei lenwi â'r manylion coll. Gellir eu gweld gan ddefnyddio'r gorchymyn:
kubernetes get networkpolicy <policy-name> -o yamlCofiwch nad yw system ddilysu Kubernetes yn anffaeledig ac efallai y bydd yn colli rhai mathau o wallau.
Gweithredu
Nid yw Kubernetes yn gweithredu polisïau rhwydwaith ei hun, ond dim ond porth API ydyw sy'n dirprwyo baich rheolaeth i system sylfaenol o'r enw'r Rhyngwyneb Rhwydweithio Cynhwyswyr (CNI). Mae gosod polisïau ar glwstwr Kubernetes heb aseinio'r CNI priodol yr un peth â chreu polisïau ar weinydd rheoli waliau tân heb eu gosod ar waliau tân wedyn. Eich cyfrifoldeb chi yw sicrhau bod gennych CNI teilwng neu, yn achos llwyfannau Kubernetes, yn cael ei gynnal yn y cwmwl (gallwch weld y rhestr o ddarparwyr — tua. traws.), galluogi polisïau rhwydwaith a fydd yn gosod CNI i chi.
Sylwch na fydd Kubernetes yn eich rhybuddio os byddwch chi'n gosod polisi rhwydwaith heb y cynorthwyydd CNI priodol.
Gwladol neu Ddi-wladwriaeth?
Mae pob CNI Kubernetes yr wyf wedi dod ar ei draws yn wladwriaethol (er enghraifft, mae Calico yn defnyddio Linux conntrack). Mae hyn yn caniatáu i'r pod dderbyn ymatebion ar y cysylltiad TCP a gychwynnodd heb orfod ei ailsefydlu. Fodd bynnag, nid wyf yn ymwybodol o safon Kubernetes a fyddai'n gwarantu cyflwr.
Rheoli Polisi Diogelwch Uwch
Dyma rai ffyrdd o wella gorfodi polisi diogelwch yn Kubernetes:
- Mae patrwm pensaernïol Rhwyll y Gwasanaeth yn defnyddio cynwysyddion ceir ochr i ddarparu telemetreg fanwl a rheolaeth traffig ar lefel gwasanaeth. Fel enghraifft gallwn ni gymryd .
- Mae rhai o werthwyr CNI wedi ymestyn eu hoffer i fynd y tu hwnt i bolisïau rhwydwaith Kubernetes.
- Yn darparu gwelededd ac awtomeiddio polisïau rhwydwaith Kubernetes.
Mae pecyn Tufin Orca yn rheoli polisïau rhwydwaith Kubernetes (a dyma ffynhonnell y sgrinluniau uchod).
gwybodaeth ychwanegol
- ;
- ;
- ;
- .
Casgliad
Mae polisïau rhwydwaith Kubernetes yn cynnig set dda o offer ar gyfer segmentu clystyrau, ond nid ydynt yn reddfol ac mae ganddynt lawer o gynildeb. Oherwydd y cymhlethdod hwn, credaf fod llawer o bolisïau clwstwr presennol yn bygi. Mae atebion posibl i'r broblem hon yn cynnwys awtomeiddio diffiniadau polisi neu ddefnyddio offer segmentu eraill.
Rwy'n gobeithio y bydd y canllaw hwn yn helpu i glirio rhai cwestiynau a datrys problemau y gallech ddod ar eu traws.
PS gan y cyfieithydd
Darllenwch hefyd ar ein blog:
- "Yn ôl i ficrowasanaethau gydag Istio": , , ;
- "Arweinlyfr Darluniadol i Rwydweithio yn Kubernetes": , ;
- «";
- «";
- «'.
Ffynhonnell: hab.com