Sveiki, Habr!

Šiuolaikinėje realybėje, augant konteinerizacijos vaidmeniui plėtros procesuose, įvairių etapų ir su konteineriais susijusių subjektų saugumo užtikrinimo klausimas yra ne mažiau svarbus klausimas. Rankinio patikrinimo atlikimas užima daug laiko, todėl būtų naudinga žengti bent pirmuosius žingsnius siekiant automatizuoti šį procesą.

Šiame straipsnyje pasidalinsiu paruoštais scenarijais, skirtais kelioms „Docker“ saugos priemonėms įdiegti, ir instrukcijomis, kaip įdiegti nedidelį demonstracinį stendą šiam procesui išbandyti. Naudodami medžiagą galite eksperimentuoti, kaip organizuoti „Dockerfile“ vaizdų ir instrukcijų saugos tikrinimo procesą. Akivaizdu, kad kiekvieno kūrimo ir diegimo infrastruktūra yra skirtinga, todėl žemiau pateiksiu keletą galimų variantų.

Apsaugos patikros komunalinės paslaugos

Yra daug įvairių pagalbinių programų ir scenarijų, kurie tikrina įvairius Docker infrastruktūros aspektus. Kai kurie iš jų jau buvo aprašyti ankstesniame straipsnyje (https://habr.com/ru/company/swordfish_security/blog/518758/#docker-security), ir šioje medžiagoje norėčiau sutelkti dėmesį į tris iš jų, kurie apima didžiąją dalį „Docker“ vaizdų, sukurtų kūrimo proceso metu, saugumo reikalavimų. Be to, taip pat parodysiu pavyzdį, kaip šias tris komunalines paslaugas galima sujungti į vieną vamzdyną, kad būtų galima atlikti saugumo patikras.

Hadolintas
https://github.com/hadolint/hadolint

Gana paprasta konsolės programa, kuri pirmiausia padeda įvertinti Dockerfile instrukcijų teisingumą ir saugumą (pavyzdžiui, naudojant tik įgaliotus vaizdų registrus arba naudojant sudo).

Dockle
https://github.com/goodwithtech/dockle

Konsolės įrankis, veikiantis su vaizdu (arba su išsaugotu vaizdo archyvu), kuris tikrina konkretaus vaizdo teisingumą ir saugumą, analizuoja jo sluoksnius ir konfigūraciją – kurie vartotojai kuriami, kokios instrukcijos naudojamos, kurios yra sumontuoti tomai, tuščias slaptažodis ir tt d. Kol kas patikrinimų skaičius nėra labai didelis ir pagrįstas keletu mūsų pačių patikrinimų ir rekomendacijų CIS (Interneto saugumo centro) etalonas Dockeriui.

Smulkmena
https://github.com/aquasecurity/trivy

Ši programa skirta rasti dviejų tipų pažeidžiamumą – problemas, susijusias su OS versijomis (palaikomos Alpine, RedHat (EL), CentOS, Debian GNU, Ubuntu) ir problemas, susijusias su priklausomybėmis (Gemfile.lock, Pipfile.lock, composer.lock, paketas). -lock.json, yarn.lock, cargo.lock). Trivy gali nuskaityti ir vaizdą saugykloje, ir vietinį vaizdą, taip pat gali nuskaityti pagal perkeltą .tar failą su Docker vaizdu.

Komunalinių paslaugų diegimo parinktys

Norėdami išbandyti aprašytas programas izoliuotoje aplinkoje, pateiksiu instrukcijas, kaip įdiegti visas programas šiek tiek supaprastintu procesu.

Pagrindinė idėja yra parodyti, kaip galite įdiegti automatinį „Dockerfiles“ ir „Docker“ vaizdų, sukurtų kūrimo metu, turinio patikrinimą.

Pats patikrinimas susideda iš šių veiksmų:

„Dockerfile“ instrukcijų teisingumo ir saugumo patikrinimas naudojant „Linter“ programą Hadolintas
Galutinių ir tarpinių vaizdų teisingumo ir saugumo patikrinimas naudojant naudingumą Dockle
Patikrinimas, ar pagrindiniame vaizde nėra viešai žinomų pažeidžiamumų (CVE) ir daugybė priklausomybių – naudojant įrankį Smulkmena

Vėliau straipsnyje pateiksiu tris šių veiksmų įgyvendinimo variantus:
Pirmasis yra CI / CD konfigūravimas naudojant GitLab kaip pavyzdį (su bandomojo egzemplioriaus kėlimo proceso aprašymu).
Antrasis yra apvalkalo scenarijaus naudojimas.
Trečiasis apima „Docker“ vaizdo kūrimą, kad būtų galima nuskaityti „Docker“ vaizdus.
Galite pasirinkti sau tinkamiausią variantą, perkelti jį į savo infrastruktūrą ir pritaikyti savo poreikiams.

Visi reikalingi failai ir papildomos instrukcijos taip pat yra saugykloje: https://github.com/Swordfish-Security/docker_cicd

Integracija į GitLab CI / CD

Pirmajame variante apžvelgsime, kaip galite atlikti saugos patikras naudodami GitLab saugyklos sistemą kaip pavyzdį. Čia mes atliksime veiksmus ir išsiaiškinsime, kaip nuo nulio įdiegti bandomąją aplinką su „GitLab“, sukurti nuskaitymo procesą ir paleisti įrankius, skirtus tikrinti bandomąjį „Dockerfile“ ir atsitiktinį vaizdą - „JuiceShop“ programą.

„GitLab“ diegimas
1. Įdiekite „Docker“:

sudo apt-get update && sudo apt-get install docker.io

2. Pridėkite dabartinį naudotoją prie docker grupės, kad galėtumėte dirbti su docker nenaudodami sudo:

sudo addgroup <username> docker

3. Raskite savo IP:

ip addr

4. Įdiekite ir paleiskite „GitLab“ konteineryje, pakeisdami IP adresą prieglobos pavadinime savo:

docker run --detach 
--hostname 192.168.1.112 
--publish 443:443 --publish 80:80 
--name gitlab 
--restart always 
--volume /srv/gitlab/config:/etc/gitlab 
--volume /srv/gitlab/logs:/var/log/gitlab 
--volume /srv/gitlab/data:/var/opt/gitlab 
gitlab/gitlab-ce:latest

Laukiame, kol „GitLab“ atliks visas būtinas diegimo procedūras (procesą galite stebėti naudodami žurnalo failo išvestį: docker logs -f gitlab).

5. Naršyklėje atidarykite vietinį IP ir pamatysite puslapį, kuriame prašoma pakeisti pagrindinio vartotojo slaptažodį:

Nustatykite naują slaptažodį ir eikite į „GitLab“.

6. Sukurkite naują projektą, pavyzdžiui, cicd-test, ir inicijuokite jį pradiniu failu README.md:

7. Dabar turime įdiegti „GitLab Runner“: agentą, kuris atliks visas reikalingas operacijas paprašius.
Atsisiųskite naujausią versiją (šiuo atveju, skirtą 64 bitų „Linux“):

sudo curl -L --output /usr/local/bin/gitlab-runner https://gitlab-runner-downloads.s3.amazonaws.com/latest/binaries/gitlab-runner-linux-amd64

8. Padarykite jį vykdomąjį:

sudo chmod +x /usr/local/bin/gitlab-runner

9. Pridėkite Runner OS naudotoją ir paleiskite paslaugą:

sudo useradd --comment 'GitLab Runner' --create-home gitlab-runner --shell /bin/bash
sudo gitlab-runner install --user=gitlab-runner --working-directory=/home/gitlab-runner
sudo gitlab-runner start

Tai turėtų atrodyti maždaug taip:

local@osboxes:~$ sudo gitlab-runner install --user=gitlab-runner --working-directory=/home/gitlab-runner
Runtime platform arch=amd64 os=linux pid=8438 revision=0e5417a3 version=12.0.1
local@osboxes:~$ sudo gitlab-runner start
Runtime platform arch=amd64 os=linux pid=8518 revision=0e5417a3 version=12.0.1

10. Dabar užregistruojame Runner, kad jis galėtų sąveikauti su mūsų GitLab egzemplioriumi.
Norėdami tai padaryti, atidarykite puslapį Settings-CI/CD (http://OUR_IP_ADDRESS/root/cicd-test/-/settings/ci_cd) ir skirtuke Runners raskite URL ir registracijos prieigos raktą:

11. Užregistruokite bėgiką pakeisdami URL ir registracijos prieigos raktą:

sudo gitlab-runner register 
--non-interactive 
--url "http://<URL>/" 
--registration-token "<Registration Token>" 
--executor "docker" 
--docker-privileged 
--docker-image alpine:latest 
--description "docker-runner" 
--tag-list "docker,privileged" 
--run-untagged="true" 
--locked="false" 
--access-level="not_protected"

Dėl to gauname paruoštą veikiantį „GitLab“, į kurį turime įtraukti instrukcijas, kad paleistume savo komunalines paslaugas. Šioje demonstracijoje mes neturime veiksmų, kaip sukurti programą ir sudėti ją į konteinerius, tačiau realioje aplinkoje tai būtų atliekama prieš nuskaitymo veiksmus ir generuojami vaizdai bei Dockerfile analizei.

dujotiekio konfigūracija

1. Pridėkite failus į saugyklą mydockerfile.df (tai yra bandomasis Docker failas, kurį patikrinsime) ir GitLab CI / CD proceso konfigūracijos failas .gitlab-cicd.yml, kuriame pateikiamos skaitytuvų instrukcijos (atkreipkite dėmesį į tašką failo pavadinime).

YAML konfigūracijos faile yra instrukcijos, kaip paleisti tris komunalines programas („Hadolint“, „Dockle“ ir „Trivy“), kurios analizuos pasirinktą „Dockerfile“ ir vaizdą, nurodytą kintamajame DOCKERFILE. Visus reikalingus failus galima paimti iš saugyklos: https://github.com/Swordfish-Security/docker_cicd/

Ištrauka iš mydockerfile.df (tai yra abstraktus failas su savavališkų instrukcijų rinkiniu tik siekiant parodyti, kaip veikia programa). Tiesioginė nuoroda į failą: mydockerfile.df

Mydockerfile.df turinys

FROM amd64/node:10.16.0-alpine@sha256:f59303fb3248e5d992586c76cc83e1d3700f641cbcd7c0067bc7ad5bb2e5b489 AS tsbuild
COPY package.json .
COPY yarn.lock .
RUN yarn install
COPY lib lib
COPY tsconfig.json tsconfig.json
COPY tsconfig.app.json tsconfig.app.json
RUN yarn build
FROM amd64/ubuntu:18.04@sha256:eb70667a801686f914408558660da753cde27192cd036148e58258819b927395
LABEL maintainer="Rhys Arkins <[email protected]>"
LABEL name="renovate"
...
COPY php.ini /usr/local/etc/php/php.ini
RUN cp -a /tmp/piik/* /var/www/html/
RUN rm -rf /tmp/piwik
RUN chown -R www-data /var/www/html
ADD piwik-cli-setup /piwik-cli-setup
ADD reset.php /var/www/html/
## ENTRYPOINT ##
ADD entrypoint.sh /entrypoint.sh
ENTRYPOINT ["/entrypoint.sh"]
USER root

YAML konfigūracija atrodo taip (patį failą galite rasti per tiesioginę nuorodą čia: .gitlab-ci.yml):

.gitlab-ci.yml turinys

variables:
    DOCKER_HOST: "tcp://docker:2375/"
    DOCKERFILE: "mydockerfile.df" # name of the Dockerfile to analyse   
    DOCKERIMAGE: "bkimminich/juice-shop" # name of the Docker image to analyse
    # DOCKERIMAGE: "knqyf263/cve-2018-11235" # test Docker image with several CRITICAL CVE
    SHOWSTOPPER_PRIORITY: "CRITICAL" # what level of criticality will fail Trivy job
    TRIVYCACHE: "$CI_PROJECT_DIR/.cache" # where to cache Trivy database of vulnerabilities for faster reuse
    ARTIFACT_FOLDER: "$CI_PROJECT_DIR"
 
services:
    - docker:dind # to be able to build docker images inside the Runner
 
stages:
    - scan
    - report
    - publish
 
HadoLint:
    # Basic lint analysis of Dockerfile instructions
    stage: scan
    image: docker:git
 
    after_script:
    - cat $ARTIFACT_FOLDER/hadolint_results.json
 
    script:
    - export VERSION=$(wget -q -O - https://api.github.com/repos/hadolint/hadolint/releases/latest | grep '"tag_name":' | sed -E 's/.*"v([^"]+)".*/1/')
    - wget https://github.com/hadolint/hadolint/releases/download/v${VERSION}/hadolint-Linux-x86_64 && chmod +x hadolint-Linux-x86_64
     
    # NB: hadolint will always exit with 0 exit code
    - ./hadolint-Linux-x86_64 -f json $DOCKERFILE > $ARTIFACT_FOLDER/hadolint_results.json || exit 0
 
    artifacts:
        when: always # return artifacts even after job failure       
        paths:
        - $ARTIFACT_FOLDER/hadolint_results.json
 
Dockle:
    # Analysing best practices about docker image (users permissions, instructions followed when image was built, etc.)
    stage: scan   
    image: docker:git
 
    after_script:
    - cat $ARTIFACT_FOLDER/dockle_results.json
 
    script:
    - export VERSION=$(wget -q -O - https://api.github.com/repos/goodwithtech/dockle/releases/latest | grep '"tag_name":' | sed -E 's/.*"v([^"]+)".*/1/')
    - wget https://github.com/goodwithtech/dockle/releases/download/v${VERSION}/dockle_${VERSION}_Linux-64bit.tar.gz && tar zxf dockle_${VERSION}_Linux-64bit.tar.gz
    - ./dockle --exit-code 1 -f json --output $ARTIFACT_FOLDER/dockle_results.json $DOCKERIMAGE   
     
    artifacts:
        when: always # return artifacts even after job failure       
        paths:
        - $ARTIFACT_FOLDER/dockle_results.json
 
Trivy:
    # Analysing docker image and package dependencies against several CVE bases
    stage: scan   
    image: docker:git
 
    script:
    # getting the latest Trivy
    - apk add rpm
    - export VERSION=$(wget -q -O - https://api.github.com/repos/knqyf263/trivy/releases/latest | grep '"tag_name":' | sed -E 's/.*"v([^"]+)".*/1/')
    - wget https://github.com/knqyf263/trivy/releases/download/v${VERSION}/trivy_${VERSION}_Linux-64bit.tar.gz && tar zxf trivy_${VERSION}_Linux-64bit.tar.gz
     
    # displaying all vulnerabilities w/o failing the build
    - ./trivy -d --cache-dir $TRIVYCACHE -f json -o $ARTIFACT_FOLDER/trivy_results.json --exit-code 0 $DOCKERIMAGE    
    
    # write vulnerabilities info to stdout in human readable format (reading pure json is not fun, eh?). You can remove this if you don't need this.
    - ./trivy -d --cache-dir $TRIVYCACHE --exit-code 0 $DOCKERIMAGE    
 
    # failing the build if the SHOWSTOPPER priority is found
    - ./trivy -d --cache-dir $TRIVYCACHE --exit-code 1 --severity $SHOWSTOPPER_PRIORITY --quiet $DOCKERIMAGE
         
    artifacts:
        when: always # return artifacts even after job failure
        paths:
        - $ARTIFACT_FOLDER/trivy_results.json
 
    cache:
        paths:
        - .cache
 
Report:
    # combining tools outputs into one HTML
    stage: report
    when: always
    image: python:3.5
     
    script:
    - mkdir json
    - cp $ARTIFACT_FOLDER/*.json ./json/
    - pip install json2html
    - wget https://raw.githubusercontent.com/shad0wrunner/docker_cicd/master/convert_json_results.py
    - python ./convert_json_results.py
     
    artifacts:
        paths:
        - results.html

Jei reikia, taip pat galite nuskaityti išsaugotus vaizdus .tar archyvo pavidalu (tačiau YAML faile turėsite pakeisti komunalinių paslaugų įvesties parametrus)

NB: Trivy reikia įdiegti min и Git. Priešingu atveju, nuskaitant „RedHat“ pagrįstus vaizdus ir gaunant pažeidžiamumo duomenų bazės naujinimus, ji sugeneruos klaidų.

2. Pridėjus failus į saugyklą, pagal mūsų konfigūracijos failo instrukcijas, „GitLab“ automatiškai pradės kūrimo ir nuskaitymo procesą. Skirtuke CI/CD → Pipelines galite matyti instrukcijų vykdymo eigą.

Dėl to turime keturias užduotis. Trys iš jų tiesiogiai susiję su nuskaitymu, o paskutinis (ataskaita) renka paprastą ataskaitą iš išsklaidytų failų su nuskaitymo rezultatais.

Pagal numatytuosius nustatymus „Trivy“ nustoja veikti, jei vaizde arba priklausomybėse aptinkami KRITINIAI pažeidžiamumai. Tuo pačiu metu Hadolint visada grąžina sėkmės kodą, nes jis visada pateikia komentarus, dėl kurių kūrimas sustabdomas.

Atsižvelgdami į konkrečius reikalavimus, galite sukonfigūruoti išėjimo kodą taip, kad kai šios paslaugos aptiktų tam tikros svarbos problemas, jos taip pat sustabdytų kūrimo procesą. Mūsų atveju kūrimas bus sustabdytas tik tuo atveju, jei „Trivy“ aptiks pažeidžiamumą, kurio kritiškumas, kurį nurodėme kintamajame SHOWSTOPPER .gitlab-ci.yml.

Kiekvienos programos rezultatą galima peržiūrėti kiekvienos nuskaitymo užduoties žurnale, tiesiogiai json failuose, esančiuose artefaktų skiltyje, arba paprastoje HTML ataskaitoje (daugiau apie tai žemiau):

3. Kad naudingų paslaugų ataskaitos būtų pateiktos šiek tiek labiau žmogui suprantama forma, naudojamas mažas Python scenarijus, kuris konvertuoja tris JSON failus į vieną HTML failą su defektų lentele.
Šis scenarijus paleidžiamas atliekant atskirą ataskaitos užduotį, o galutinis jo artefaktas yra HTML failas su ataskaita. Scenarijaus šaltinis taip pat yra saugykloje ir gali būti pritaikytas pagal jūsų poreikius, spalvas ir pan.

Shell scenarijus

Antroji parinktis tinka tais atvejais, kai reikia patikrinti „Docker“ vaizdus už CI / CD sistemos ribų arba jums reikia turėti visas instrukcijas tokia forma, kurią būtų galima vykdyti tiesiogiai pagrindiniame kompiuteryje. Ši parinktis apima paruoštą apvalkalo scenarijų, kurį galima paleisti švarioje virtualioje (ar net tikroje) mašinoje. Scenarijus vykdo tas pačias instrukcijas kaip ir aukščiau aprašytas gitlab-runner.

Kad scenarijus būtų sėkmingai paleistas, sistemoje turi būti įdiegtas „Docker“, o dabartinis vartotojas turi būti dokerių grupėje.

Patį scenarijų rasite čia: docker_sec_check.sh

Failo pradžioje kintamieji nurodo, kurį vaizdą reikia nuskaityti ir dėl kokių kritiškumo defektų „Trivy“ programa išeis su nurodytu klaidos kodu.

Vykdant scenarijų visos paslaugos bus atsisiųstos į katalogą docker_tools, jų darbo rezultatai yra kataloge docker_tools/json, o HTML su ataskaita bus faile rezultatai.html.

Scenarijaus išvesties pavyzdys

~/docker_cicd$ ./docker_sec_check.sh

[+] Setting environment variables
[+] Installing required packages
[+] Preparing necessary directories
[+] Fetching sample Dockerfile
2020-10-20 10:40:00 (45.3 MB/s) - ‘Dockerfile’ saved [8071/8071]
[+] Pulling image to scan
latest: Pulling from bkimminich/juice-shop
[+] Running Hadolint
...
Dockerfile:205 DL3015 Avoid additional packages by specifying `--no-install-recommends`
Dockerfile:248 DL3002 Last USER should not be root
...
[+] Running Dockle
...
WARN    - DKL-DI-0006: Avoid latest tag
        * Avoid 'latest' tag
INFO    - CIS-DI-0005: Enable Content trust for Docker
        * export DOCKER_CONTENT_TRUST=1 before docker pull/build
...
[+] Running Trivy
juice-shop/frontend/package-lock.json
=====================================
Total: 3 (UNKNOWN: 0, LOW: 1, MEDIUM: 0, HIGH: 2, CRITICAL: 0)

+---------------------+------------------+----------+---------+-------------------------+
|       LIBRARY       | VULNERABILITY ID | SEVERITY | VERSION |             TITLE       |
+---------------------+------------------+----------+---------+-------------------------+
| object-path         | CVE-2020-15256   | HIGH     | 0.11.4  | Prototype pollution in  |
|                     |                  |          |         | object-path             |
+---------------------+------------------+          +---------+-------------------------+
| tree-kill           | CVE-2019-15599   |          | 1.2.2   | Code Injection          |
+---------------------+------------------+----------+---------+-------------------------+
| webpack-subresource | CVE-2020-15262   | LOW      | 1.4.1   | Unprotected dynamically |
|                     |                  |          |         | loaded chunks           |
+---------------------+------------------+----------+---------+-------------------------+

juice-shop/package-lock.json
============================
Total: 20 (UNKNOWN: 0, LOW: 1, MEDIUM: 6, HIGH: 8, CRITICAL: 5)

...

juice-shop/package-lock.json
============================
Total: 5 (CRITICAL: 5)

...
[+] Removing left-overs
[+] Making the output look pretty
[+] Converting JSON results
[+] Writing results HTML
[+] Clean exit ============================================================
[+] Everything is done. Find the resulting HTML report in results.html

Docker vaizdas su visomis komunalinėmis paslaugomis

Kaip trečia alternatyva, aš sukūriau du paprastus „Docker“ failus, kad sukurčiau vaizdą su saugos priemonėmis. Vienas „Dockerfile“ padės sukurti rinkinį vaizdo nuskaitymui iš saugyklos, antrasis („Dockerfile_tar“) padės sukurti rinkinį tar failo nuskaitymui su vaizdu.

1. Paimkite atitinkamą Docker failą ir scenarijus iš saugyklos https://github.com/Swordfish-Security/docker_cicd/tree/master/Dockerfile.
2. Paleidžiame jį surinkti:

docker build -t dscan:image -f docker_security.df .

3. Baigę surinkimą, iš paveikslėlio sukuriame konteinerį. Tuo pačiu metu perduodame DOCKERIMAGE aplinkos kintamąjį su mus dominančio vaizdo pavadinimu ir sujungiame Docker failą, kurį norime analizuoti iš savo įrenginio į failą /Dockerfile (atminkite, kad būtinas absoliutus kelias į šį failą):

docker run --rm -v $(pwd)/results:/results -v $(pwd)/docker_security.df:/Dockerfile -e DOCKERIMAGE="bkimminich/juice-shop" dscan:image


[+] Setting environment variables
[+] Running Hadolint
/Dockerfile:3 DL3006 Always tag the version of an image explicitly
[+] Running Dockle
WARN    - DKL-DI-0006: Avoid latest tag
        * Avoid 'latest' tag
INFO    - CIS-DI-0005: Enable Content trust for Docker
        * export DOCKER_CONTENT_TRUST=1 before docker pull/build
INFO    - CIS-DI-0006: Add HEALTHCHECK instruction to the container image
        * not found HEALTHCHECK statement
INFO    - DKL-LI-0003: Only put necessary files
        * unnecessary file : juice-shop/node_modules/sqlite3/Dockerfile
        * unnecessary file : juice-shop/node_modules/sqlite3/tools/docker/architecture/linux-arm64/Dockerfile
        * unnecessary file : juice-shop/node_modules/sqlite3/tools/docker/architecture/linux-arm/Dockerfile
[+] Running Trivy
...
juice-shop/package-lock.json
============================
Total: 20 (UNKNOWN: 0, LOW: 1, MEDIUM: 6, HIGH: 8, CRITICAL: 5)
...
[+] Making the output look pretty
[+] Starting the main module ============================================================
[+] Converting JSON results
[+] Writing results HTML
[+] Clean exit ============================================================
[+] Everything is done. Find the resulting HTML report in results.html

rezultatai

Pažiūrėjome tik į vieną pagrindinį „Docker“ artefaktų nuskaitymo paslaugų rinkinį, kuris, mano nuomone, labai efektyviai atitinka nemažą dalį vaizdo saugumo reikalavimų. Taip pat yra daug mokamų ir nemokamų įrankių, kurie gali atlikti tuos pačius patikrinimus, sudaryti gražias ataskaitas arba dirbti tik konsolės režimu, padengti konteinerių valdymo sistemas ir pan. Šių įrankių ir jų integravimo apžvalga gali būti pateikta šiek tiek vėliau. .

Šiame straipsnyje aprašyto įrankių rinkinio pranašumas yra tas, kad jie visi yra atvirojo kodo ir galite eksperimentuoti su jais bei kitais panašiais įrankiais, kad surastumėte tai, kas atitinka jūsų poreikius ir infrastruktūrą. Žinoma, visi aptikti pažeidžiamumai turėtų būti ištirti, kad būtų galima pritaikyti tam tikromis sąlygomis, tačiau tai yra būsimo didelio straipsnio tema.

Tikiuosi, kad šis vadovas, scenarijai ir priemonės padės jums ir taps atskaitos tašku kuriant saugesnę konteinerių talpinimo infrastruktūrą.

Šaltinis: www.habr.com

Komunalinių paslaugų, skirtų „Docker“ saugumui tikrinti, diegimo metodai ir pavyzdžiai