🥇Entwodiksyon Règleman Rezo Kubernetes pou Pwofesyonèl Sekirite

Remak. trad.: Otè atik la, Reuven Harrison, gen plis pase 20 ane eksperyans nan devlopman lojisyèl, e jodi a se CTO ak ko-fondatè Tufin, yon konpayi ki kreye solisyon jesyon politik sekirite. Pandan ke li konsidere politik rezo Kubernetes kòm yon zouti jistis pwisan pou segmentasyon rezo nan yon gwoup, li kwè tou ke yo pa tèlman fasil aplike nan pratik. Materyèl sa a (byen volumineuz) gen entansyon amelyore konsyans espesyalis yo sou pwoblèm sa a epi ede yo kreye konfigirasyon ki nesesè yo.

Jodi a, anpil konpayi yo ap chwazi de pli zan pli Kubernetes pou kouri aplikasyon yo. Enterè nan lojisyèl sa a tèlman wo ke kèk moun ap rele Kubernetes "nouvo sistèm operasyon pou sant done a." Piti piti, Kubernetes (oswa k8s) kòmanse konsidere kòm yon pati enpòtan nan biznis la, ki mande pou òganizasyon an nan pwosesis biznis ki gen matirite, ki gen ladan sekirite rezo.

Pou pwofesyonèl sekirite ki dekonpoze lè yo travay ak Kubernetes, vrè revelasyon an ka politik default platfòm la: pèmèt tout bagay.

Gid sa a pral ede w konprann estrikti entèn politik rezo yo; konprann ki jan yo diferan de règ yo pou firewall regilye. Li pral kouvri tou kèk enkonvenyans ak bay rekòmandasyon pou ede aplikasyon an sekirite sou Kubernetes.

Règleman rezo Kubernetes

Mekanis politik rezo Kubernetes pèmèt ou jere entèraksyon aplikasyon yo deplwaye sou platfòm la nan kouch rezo a (twazyèm lan nan modèl OSI). Règleman rezo yo manke kèk nan karakteristik avanse nan firewall modèn, tankou ranfòsman OSI Layer 7 ak deteksyon menas, men yo bay yon nivo debaz sekirite rezo ki se yon bon pwen depa.

Règleman rezo kontwole kominikasyon ant gous yo

Chaj travay nan Kubernetes yo distribye atravè gous, ki konpoze de youn oswa plizyè resipyan deplwaye ansanm. Kubernetes bay chak gous yon adrès IP ki aksesib nan lòt gous. Règleman rezo Kubernetes yo mete dwa aksè pou gwoup gous yo menm jan ak gwoup sekirite nan nwaj la yo itilize pou kontwole aksè nan ka machin vityèl.

Defini Règleman Rezo

Menm jan ak lòt resous Kubernetes, règleman rezo yo espesifye nan YAML. Nan egzanp ki anba a, aplikasyon an balance aksè a 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

(Remak. trad.: Ekran sa a, tankou tout lòt menm jan an ki vin apre yo, te kreye pa sèvi ak zouti natif natal Kubernetes, men lè l sèvi avèk zouti nan Tufin Orca, ki te devlope pa konpayi an nan otè a nan atik orijinal la epi ki mansyone nan fen materyèl la.)

Pou defini pwòp politik rezo ou, w ap bezwen konesans debaz nan YAML. Lang sa a baze sou endentasyon (ki espesifye pa espas olye ke tab). Yon eleman indentée fè pati eleman indented ki pi pre a anlè li. Yon nouvo eleman lis kòmanse ak yon tire, tout lòt eleman gen fòm nan kle-valè.

Èske w gen dekri politik la nan YAML, sèvi ak kubectlpou kreye li nan gwoup la:

kubectl create -f policy.yaml

Espesifikasyon politik rezo

Espesifikasyon politik rezo Kubernetes gen ladan kat eleman:

podSelector: defini gous ki afekte nan règleman sa a (sib) - obligatwa;
policyTypes: endike ki kalite politik yo enkli nan sa a: antre ak/oswa sòti - si ou vle, men mwen rekòmande pou presize li klèman nan tout ka;
ingress: defini pèmèt fèk ap rantre trafik pou sib gous - si ou vle;
egress: defini pèmèt sortan trafik soti nan gous sib se opsyonèl.

Egzanp yo pran nan sit entènèt Kubernetes (mwen ranplase role sou app), montre kouman yo itilize tout kat eleman:

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

Tanpri sonje ke tout kat eleman yo pa dwe enkli. Li se sèlman obligatwa podSelector, lòt paramèt ka itilize jan ou vle.

Si nou omite policyTypes, yo pral entèprete politik la jan sa a:

Pa default, li sipoze ke li defini bò a antre. Si règleman an pa endike sa a klèman, sistèm nan pral asime ke tout trafik entèdi.
Konpòtman sou bò sòti a pral detèmine pa prezans oswa absans paramèt sòti korespondan an.

Pou evite erè mwen rekòmande toujou fè li klè policyTypes.

Dapre lojik ki anwo a, si paramèt yo ingress ak / oswa egress omisyon, règleman an pral refize tout trafik (gade "Règ dezabiye" anba a).

Default politik se Pèmèt

Si pa gen okenn règleman yo defini, Kubernetes pèmèt tout trafik pa default. Tout gous yo ka lib echanj enfòmasyon nan mitan yo. Sa a ka sanble counterintuitive nan yon pèspektiv sekirite, men sonje ke Kubernetes te orijinal fèt pa devlopè yo ki ap pèmèt entèoperabilite aplikasyon an. Politik rezo yo te ajoute pita.

Espas non yo

Espas non yo se mekanis kolaborasyon Kubernetes. Yo fèt yo izole anviwònman ki lojik youn ak lòt, pandan y ap kominikasyon ant espas yo pèmèt pa default.

Tankou pifò konpozan Kubernetes, politik rezo ap viv nan yon espas non espesifik. Nan blòk la metadata ou ka presize nan ki espas politik la fè pati:

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

Si espas non an pa espesifikman espesifye nan metadata yo, sistèm lan pral sèvi ak espas non ki espesifye nan kubectl (pa default namespace=default):

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

Mwen rekòmande espesifye espas non klèman, sof si w ap ekri yon politik ki vize plizyè espas non an menm tan.

Prensipal la eleman podSelector nan politik la pral chwazi gous soti nan espas non a ki politik la fè pati (li se refize aksè nan gous soti nan yon lòt espas non).

Menm jan an tou, podSelectors nan blòk antre ak sòti ka sèlman chwazi gous nan pwòp espas non yo, sof si nan kou ou konbine yo ak namespaceSelector (sa a pral diskite nan seksyon "Filtre pa espas non ak gous").

Règ pou nonmen règleman yo

Non politik yo inik nan menm espas non an. Pa kapab genyen de politik ki gen menm non nan menm espas la, men kapab genyen politik ki gen menm non nan diferan espas. Sa a itil lè ou vle reaplike menm politik la nan plizyè espas.

Mwen espesyalman renmen youn nan metòd yo nonmen. Li konsiste de konbine non espas non an ak gous sib yo. Pa egzanp:

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

Etikèt

Ou ka tache etikèt koutim nan objè Kubernetes, tankou gous ak espas non. Etikèt (etikèt - Tags) se ekivalan a nan tags nan nwaj la. Règleman rezo Kubernetes yo itilize etikèt pou chwazi gouskote yo aplike:

podSelector:
  matchLabels:
    role: db

… oswa espas non yokote yo aplike. Egzanp sa a chwazi tout gous nan espas non ak etikèt ki koresponn yo:

namespaceSelector:
  matchLabels:
    project: myproject

Yon prekosyon: lè w ap itilize namespaceSelector asire w ke espas non ou chwazi yo genyen etikèt ki kòrèk la. Ou dwe konnen ke espas non entegre tankou default и kube-system, pa default pa genyen etikèt.

Ou ka ajoute yon etikèt nan yon espas tankou sa a:

kubectl label namespace default namespace=default

An menm tan an, espas non nan seksyon an metadata ta dwe refere a non espas aktyèl la, pa etikèt la:

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

Sous ak destinasyon

Règleman firewall konpoze de règ ak sous ak destinasyon. Politik rezo Kubernetes yo defini pou yon sib - yon seri gous kote yo aplike - epi answit mete règ pou trafik antre ak/oswa sòti. Nan egzanp nou an, sib la nan politik la pral tout gous nan espas non an default ak etikèt ak kle app ak siyifikasyon 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

Sou-seksyon ingress nan règleman sa a, ouvè trafik fèk ap rantre nan gous yo sib. Nan lòt mo, antre se sous la ak sib se destinasyon ki koresponn lan. Menm jan an tou, sòti se destinasyon an ak sib se sous li.

Sa a ekivalan a de règ firewall: Antre → Sib; Objektif → Sòti.

Sòti ak DNS (enpòtan!)

Lè limite trafik sortan, peye atansyon espesyal sou DNS - Kubernetes sèvi ak sèvis sa a pou kat sèvis nan adrès IP. Pa egzanp, règleman sa yo p ap travay paske ou pa pèmèt aplikasyon an balance aksè 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

Ou ka ranje li lè w louvri aksè nan sèvis DNS la:

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

Dènye eleman to se vid, ak Se poutèt sa li endirèkteman chwazi tout gous nan tout espas non yo, ki pèmèt balance voye demann DNS nan sèvis Kubernetes ki apwopriye a (anjeneral kouri nan espas la kube-system).

Apwòch sa a ap travay, sepandan li twò toleran ak ensekirite, paske li pèmèt demann DNS yo dwe dirije deyò gwoup la.

Ou ka amelyore li nan twa etap siksesif.

1. Pèmèt demann DNS sèlman andedan grap pa ajoute 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. Pèmèt demann DNS nan espas non sèlman kube-system.

Pou fè sa ou bezwen ajoute yon etikèt nan espas non an kube-system: kubectl label namespace kube-system namespace=kube-system - epi ekri li nan règleman lè l sèvi avèk 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. moun paranoïaque ka ale menm pi lwen Et limite requêtes DNS pou yon sèvis DNS espesifik nan kube-system. Seksyon "Filtre pa espas non AK gous" pral di w kijan pou reyalize sa.

Yon lòt opsyon se rezoud DNS nan nivo espas non an. Nan ka sa a, li pa pral bezwen louvri pou chak sèvis:

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

Vide podSelector chwazi tout gous nan espas non an.

Premye match ak lòd règ

Nan firewall konvansyonèl yo, aksyon an (Pèmèt oswa refize) sou yon pake detèmine pa règ nan premye ke li satisfè. Nan Kubernetes, lòd politik yo pa gen pwoblèm.

Pa defo, lè yo pa mete okenn politik, kominikasyon ant gous yo gen dwa epi yo ka lib echanj enfòmasyon. Yon fwa ou kòmanse fòmile politik, chak gous ki afekte nan omwen youn nan yo vin izole dapre disjonksyon an (OSWA lojik) nan tout politik yo ki te chwazi li. Gous ki pa afekte pa okenn politik rete ouvè.

Ou ka chanje konpòtman sa a lè l sèvi avèk yon règ nidite.

Règ dezabiye ("Refize")

Politik firewall anjeneral refize nenpòt trafik ki pa klèman pèmèt.

Pa gen okenn aksyon refize nan Kubernetes, sepandan, yon efè menm jan an ka reyalize ak yon politik regilye (permisif) lè w chwazi yon gwoup vid gous sous (antre):

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

Règleman sa a chwazi tout gous nan espas non an epi kite antre san defini, li refize tout trafik k ap rantre.

Nan yon fason menm jan an, ou ka mete restriksyon sou tout trafik soti nan yon espas non:

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

Tanpri note ke nenpòt règleman adisyonèl ki pèmèt trafik nan gous nan espas non an pral pran priyorite sou règ sa a (menm jan ak ajoute yon règ pèmèt anvan yon règ refize nan yon konfigirasyon firewall).

Pèmèt tout bagay (Nenpòt-Nenpòt-Nenpòt-Pèmèt)

Pou kreye yon politik Pèmèt Tout, ou bezwen konplete politik Refi anlè a ak yon eleman vid ingress:

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

Li pèmèt aksè nan tout gous nan tout espas non yo (ak tout IP) nan nenpòt gous nan espas non an default. Konpòtman sa a pèmèt pa default, kidonk li anjeneral pa bezwen defini plis. Sepandan, pafwa ou ka bezwen enfim tanporèman kèk otorizasyon espesifik pou fè dyagnostik pwoblèm nan.

Règ la kapab réduit desann pou pèmèt aksè sèlman pou yon seri gous espesifik (app:balance) nan espas non an default:

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

Règleman sa a pèmèt tout trafik antre ak sòti, ki gen ladan aksè a nenpòt IP deyò gwoup la:

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

Konbine plizyè politik

Règ yo konbine lè l sèvi avèk lojik OSWA nan twa nivo; Otorizasyon chak gous yo mete an akò ak disjonksyon tout politik ki afekte li:

1. Nan jaden yo from и to Twa kalite eleman yo ka defini (tout yo konbine avèk OSWA):

namespaceSelector — chwazi espas non an antye;
podSelector - chwazi gous;
ipBlock — chwazi yon sous-rezo.

Anplis, kantite eleman (menm ki idantik) nan sou-seksyon yo from/to pa limite. Tout nan yo pral konbine pa lojik OR.

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. Anndan seksyon politik la ingress ka gen anpil eleman from (konbine pa lojik OSWA). Menm jan an tou, seksyon egress ka gen ladann anpil eleman to (tou konbine pa disjonksyon):

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. Diferan politik yo tou konbine avèk lojik OR

Men, lè yo konbine yo, gen yon sèl limit sou ki fè remake Chris Cooney: Kubernetes ka sèlman konbine politik ak diferan policyTypes (Ingress oswa Egress). Règleman ki defini antre (oswa sòti) pral ranplase youn ak lòt.

Relasyon ant espas non yo

Pa default, pataje enfòmasyon ant espas non yo pèmèt. Sa a ka chanje lè w sèvi ak yon politik refi ki pral mete restriksyon sou trafik soti ak/oswa antre nan espas non an (gade "Règ dezabiye" pi wo a).

Yon fwa ou te bloke aksè a yon espas non (gade "Règ dezabiye" anlè a), ou ka fè eksepsyon nan règleman an refize lè w pèmèt koneksyon ki soti nan yon espas non espesifik lè w itilize 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

Kòm yon rezilta, tout gous nan namespace la default pral gen aksè a gous postgres nan espas non database. Men, e si ou vle louvri aksè a postgres sèlman gous espesifik nan espas non an default?

Filtre pa espas non ak gous

Kubernetes vèsyon 1.11 ak pi wo pèmèt ou konbine operatè yo namespaceSelector и podSelector lè l sèvi avèk lojik AND. Li sanble sa a:

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

Poukisa sa a entèprete kòm AND olye de abityèl OR?

sonje ke podSelector pa kòmanse ak yon tiret. Nan YAML sa vle di sa podSelector ak kanpe devan l ' namespaceSelector al gade nan menm eleman lis la. Se poutèt sa, yo konbine avèk lojik AND.

Ajoute yon tire anvan podSelector pral lakòz aparisyon nan yon nouvo eleman lis, ki pral konbine avèk yon sèl anvan an namespaceSelector itilize OSWA ki lojik.

Pou chwazi gous ak yon etikèt espesifik nan tout espas non yo, antre vid 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

Plizyè etikèt ekipe ak I

Règ pou yon firewall ak plizyè objè (lame, rezo, gwoup) yo konbine lè l sèvi avèk lojik OSWA. Règ sa a ap travay si sous pake a matche Host_1 OSWA Host_2:

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

Okontrè, nan Kubernetes etikèt yo divès kalite nan podSelector oswa namespaceSelector yo konbine avèk AND lojik. Pa egzanp, règ sa a pral chwazi gous ki gen tou de etikèt, role=db И version=v2:

podSelector:
  matchLabels:
    role: db
    version: v2

Menm lojik la aplike pou tout kalite operatè yo: seleksyon sib politik, seleksyon gous, ak seleksyon espas non.

Sou-rezo ak adrès IP (IPBlocks)

Firewall yo itilize VLAN, adrès IP, ak subnets pou segman yon rezo.

Nan Kubernetes, adrès IP yo asiyen nan gous otomatikman epi yo ka chanje souvan, kidonk etikèt yo itilize pou chwazi gous ak espas non nan règleman rezo yo.

Sourezo (ipBlocks) yo itilize lè yo jere koneksyon ekstèn (Nò-Sid) ki fèk ap rantre oswa ki soti (soti). Pou egzanp, règleman sa a ouvè a tout gous ki soti nan espas non an default aksè nan sèvis 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

Selektè gous vid nan egzanp sa a vle di "chwazi tout gous nan espas non an."

Règleman sa a sèlman pèmèt aksè a 8.8.8.8; aksè a nenpòt lòt IP entèdi. Se konsa, nan sans, ou te bloke aksè nan sèvis entèn Kubernetes dns la. Si ou toujou vle ouvri li, endike sa a klèman.

Anjeneral ipBlocks и podSelectors yo mityèlman eksklizif, depi adrès IP entèn gous yo pa itilize nan ipBlocks. Pa endike gous IP entèn yo, ou pral aktyèlman pèmèt koneksyon pou/soti nan gous ak adrès sa yo. Nan pratik, ou pa pral konnen ki adrès IP yo itilize, se poutèt sa yo pa ta dwe itilize yo chwazi gous.

Kòm yon kont-egzanp, règleman sa a gen ladan tout IP epi kidonk pèmèt aksè a tout lòt gous:

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

Ou ka louvri aksè sèlman nan IP ekstèn, eksepte adrès IP entèn gous yo. Pou egzanp, si subnet gous ou a se 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

Pò ak pwotokòl

Tipikman gous koute yon sèl pò. Sa vle di ke ou ka tou senpleman pa presize nimewo pò nan règleman yo epi kite tout bagay kòm default. Sepandan, li rekòmande pou fè politik kòm restriksyon ke posib, kidonk nan kèk ka ou ka toujou presize pò:

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

Remake byen ke seleksyon an ports aplike nan tout eleman nan blòk la to oswa from, ki gen ladann. Pou presize pò diferan pou diferan seri eleman, divize ingress oswa egress nan plizyè sou-seksyon ak to oswa from epi nan chak anrejistre pò ou yo:

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

Operasyon pò default:

Si ou kite definisyon pò a nèt (ports), sa vle di tout pwotokòl ak tout pò;
Si ou omite definisyon pwotokòl la (protocol), sa vle di TCP;
Si ou kite definisyon pò a (port), sa vle di tout pò yo.

Pi bon pratik: Pa konte sou valè default, presize sa ou bezwen klèman.

Tanpri sonje ke ou dwe itilize pò gous, pa pò sèvis (plis sou sa a nan paragraf kap vini an).

Èske règleman yo defini pou gous oswa sèvis?

Tipikman, gous nan Kubernetes jwenn aksè youn ak lòt atravè yon sèvis - yon balanse chaj vityèl ki redireksyon trafik nan gous yo ki aplike sèvis la. Ou ta ka panse ke politik rezo kontwole aksè nan sèvis yo, men sa a se pa ka a. Règleman rezo Kubernetes yo travay sou pò pod, pa pò sèvis yo.

Pou egzanp, si yon sèvis koute pò 80, men redireksyon trafik nan pò 8080 nan gous li yo, ou dwe presize egzakteman 8080 nan politik rezo a.

Yo ta dwe konsidere yon mekanis sa yo ki pa pi bon: si estrikti entèn sèvis la (pò yo ki gous koute) chanje, règleman rezo yo pral oblije mete ajou.

Nouvo apwòch achitekti lè l sèvi avèk Service Mesh (pa egzanp, gade sou Istio pi ba a - apeprè trad.) pèmèt ou fè fas ak pwoblèm sa a.

Èske li nesesè pou anrejistre tou de Antre ak Soti?

Repons kout la se wi, pou gous A kominike ak gous B, li dwe gen dwa kreye yon koneksyon sortan (pou sa ou bezwen konfigirasyon yon politik egress), epi pod B dwe kapab aksepte yon koneksyon fèk ap rantre ( pou sa, kòmsadwa, ou bezwen yon politik antre).

Sepandan, nan pratik, ou ka konte sou règleman default la pou pèmèt koneksyon nan youn oswa toude direksyon.

Si kèk gous-sous yo pral chwazi pa youn oswa plis sòti-politisyen yo, restriksyon yo enpoze sou li pral detèmine pa disjonksyon yo. Nan ka sa a, w ap bezwen klèman pèmèt koneksyon ak gous la -destinataire. Si okenn politik pa chwazi yon gous, trafik sòtan (sòti) li otorize pa defo.

Menm jan an tou, sò a nan gous la sedestinataire, chwazi pa youn oswa plis pénétrer-politisyen, yo pral detèmine pa disjonksyon yo. Nan ka sa a, ou dwe klèman pèmèt li resevwa trafik nan gous sous la. Si okenn politik pa chwazi yon gous, tout trafik antre pou li gen dwa pa defo.

Gade Eta oswa Apatrid anba a.

Logs

Règleman rezo Kubernetes pa ka konekte trafik. Sa fè li difisil pou detèmine si yon politik ap travay jan sa vle di epi li konplike anpil analiz sekirite.

Kontwòl trafik nan sèvis ekstèn

Règleman rezo Kubernetes yo pa pèmèt ou presize yon non domèn konplètman kalifye (DNS) nan seksyon sòti yo. Reyalite sa a mennen nan deranjman enpòtan lè w ap eseye limite trafik nan destinasyon ekstèn ki pa gen yon adrès IP fiks (tankou aws.com).

Tcheke Règleman

Firewall yo pral avèti ou oswa menm refize aksepte move politik la. Kubernetes tou fè kèk verifikasyon. Lè w ap fikse yon politik rezo atravè kubectl, Kubernetes ka deklare li pa kòrèk epi refize aksepte li. Nan lòt ka, Kubernetes pral pran politik la epi ranpli li ak detay ki manke yo. Yo ka wè lè l sèvi avèk kòmandman an:

kubernetes get networkpolicy <policy-name> -o yaml

Kenbe nan tèt ou ke sistèm validation Kubernetes la pa enfayib epi li ka manke kèk kalite erè.

Egzekisyon

Kubernetes pa aplike politik rezo tèt li, men se jis yon pòtay API ki delege chay kontwòl la nan yon sistèm kache ki rele Container Networking Interface (CNI). Mete règleman sou yon gwoup Kubernetes san yo pa bay CNI apwopriye a se menm jan ak kreye règleman sou yon sèvè jesyon firewall san yo pa enstale yo sou firewall. Se ou menm ki pou asire ou gen yon CNI desan oswa, nan ka platfòm Kubernetes, òganize nan nwaj la. (ou ka wè lis founisè yo isit la -apeprè trans.), pèmèt politik rezo ki pral mete CNI pou ou.

Remake byen ke Kubernetes pa pral avèti ou si ou mete yon politik rezo san asistan CNI apwopriye a.

Eta oswa Apatrid?

Tout CNI Kubernetes mwen te rankontre yo gen eta (pa egzanp, Calico itilize Linux conntrack). Sa a pèmèt gous la resevwa repons sou koneksyon TCP li inisye san yo pa oblije re-etabli li. Sepandan, mwen pa okouran de yon estanda Kubernetes ki ta garanti eta.

Jesyon politik sekirite avanse

Men kèk fason pou amelyore ranfòsman politik sekirite nan Kubernetes:

Modèl achitekti Service Mesh la sèvi ak veso sidecar pou bay telemetri detaye ak kontwòl trafik nan nivo sèvis la. Kòm yon egzanp nou ka pran Istio.
Kèk nan machann CNI yo te pwolonje zouti yo pou ale pi lwen politik rezo Kubernetes.
Tufin Orca Bay vizibilite ak automatisation nan politik rezo Kubernetes.

Pake Tufin Orca jere politik rezo Kubernetes (epi se sous Ekran ki anwo yo).

Lòt enfòmasyon

Konklizyon

Règleman rezo Kubernetes yo ofri yon bon seri zouti pou segman gwoup, men yo pa entwisyon epi yo gen anpil sibtilite. Akoz konpleksite sa a, mwen kwè ke anpil politik gwoup ki egziste deja gen pwoblèm. Solisyon posib pou pwoblèm sa a gen ladan otomatize definisyon politik oswa itilize lòt zouti segmentasyon.

Mwen espere gid sa a ede klè kèk kesyon ak rezoud pwoblèm ou ka rankontre.

PS soti nan tradiktè

Li tou sou blog nou an:

"Retounen nan mikwosèvis ak Istio": Pati 1 (entwodiksyon nan karakteristik prensipal yo), Pati 2 (routage, kontwòl trafik), Pati 3 (sekirite);
"Yon Gid ilistre pou rezo nan Kubernetes": pati 1 ak 2 (modèl rezo, rezo kouvri), Pati 3 (sèvis ak pwosesis trafik);
«Docker ak Kubernetes nan anviwònman ki mande sekirite";
«9 Meyè Pratik pou Sekirite Kubernetes";
«11 Fason pou (pa) vin yon viktim yon Hack Kubernetes'.

Sous: www.habr.com

Yon Entwodiksyon nan Règleman Rezo Kubernetes pou Pwofesyonèl Sekirite