[{"data":1,"prerenderedAt":1690},["ShallowReactive",2],{"topic:aidt-bac-cloud_tech:topic-03":3},{"content":4,"pz":251,"lr":262,"additional":251,"courseMeta":1647},{"id":5,"title":6,"body":7,"course_slug":250,"description":232,"env_label":251,"env_url":251,"extension":252,"group":251,"is_course_project":253,"is_index":253,"level":251,"meta":254,"navigation":255,"path":256,"section":257,"seo":258,"stem":259,"topic_number":239,"topic_slug":260,"__hash__":261},"courses\u002Fcourses\u002Faidt-bac-cloud_tech\u002Ftopic-03-content.md","Контейнеризация и архитектура Docker",{"type":8,"value":9,"toc":231},"minimark",[10,14,19,23,26,29,33,36,39,42,45,50,53,56,59,63,66,78,82,85,88,91,99,102,106,109,112,115,118,121,124,127,130,138,141,145,148,151,154,162,165,169,172,175,183,186,190,193,201,204,208,211,214,218,221,224,228],[11,12,6],"h1",{"id":13},"контейнеризация-и-архитектура-docker",[15,16,18],"h2",{"id":17},"контейнер-как-модель-изоляции-процессов","Контейнер как модель изоляции процессов",[20,21,22],"p",{},"Контейнеризация решает практическую задачу: запускать приложения изолированно и воспроизводимо, не создавая для каждого приложения отдельную виртуальную машину. В отличие от VM, контейнер не содержит собственного ядра операционной системы. Контейнер — это набор процессов, которые выполняются на ядре хоста, но «видят» ограниченную картину системы: свои процессы, свою файловую систему, свои сетевые интерфейсы и свои квоты ресурсов. Эта изоляция достигается механизмами ядра Linux, а Docker предоставляет удобную модель упаковки и запуска.",[20,24,25],{},"Ключевое отличие контейнера от виртуальной машины проявляется на уровне ядра операционной системы. Виртуальная машина запускает полноценную гостевую ОС поверх гипервизора и требует выделения ресурсов на её обслуживание. Контейнер же разделяет ядро хоста с другими контейнерами, что существенно сокращает время запуска — с минут до секунд — и снижает накладные расходы на оперативную память и дисковое пространство.",[20,27,28],{},"Практический смысл контейнеризации раскрывается на всех этапах жизненного цикла приложения. На этапе разработки контейнер позволяет воспроизвести окружение, идентичное целевому, и устранить расхождения между рабочими станциями участников команды. На этапе тестирования контейнеры обеспечивают быстрое создание и уничтожение изолированных сред, необходимых для проверки различных конфигураций. На этапе эксплуатации контейнеризация упрощает развёртывание и обновление приложений, поскольку образ контейнера является единым переносимым артефактом, содержащим приложение и все его зависимости.",[15,30,32],{"id":31},"сопоставление-с-виртуализацией","Сопоставление с виртуализацией",[20,34,35],{},"Контейнеризация и виртуализация решают общую задачу — изоляцию вычислительных сред — но принципиально различаются уровнем, на котором эта изоляция реализуется. Понимание этих различий необходимо для обоснованного выбора подхода при проектировании инфраструктуры.",[20,37,38],{},"Виртуальная машина представляет собой полноценную вычислительную среду с собственной операционной системой. Гипервизор обеспечивает аппаратную изоляцию: гостевая система не имеет прямого доступа к ресурсам хоста или других виртуальных машин. Границы изоляции проходят на уровне виртуального оборудования, что обеспечивает высокую степень безопасности. Даже если гостевая операционная система подвергнется компрометации, злоумышленнику потребуется преодолеть дополнительный барьер в виде гипервизора, чтобы получить доступ к хостовой системе.",[20,40,41],{},"Контейнер не содержит собственной операционной системы и не требует гипервизора. Изоляция обеспечивается средствами ядра хостовой системы — пространствами имён и группами управления ресурсами, рассмотренными в предыдущей теме. С точки зрения хостовой системы контейнер представляет собой процесс (или группу процессов) в ограниченном окружении. Это даёт ряд практических преимуществ: минимальные накладные расходы (нет необходимости загружать дополнительную операционную систему), быстрый запуск (секунды вместо минут) и компактность артефакта (контейнерный образ содержит только приложение и его зависимости).",[20,43,44],{},"Вместе с тем изоляция средствами ядра менее строга, чем аппаратная изоляция гипервизора. Уязвимость в ядре хостовой системы потенциально затрагивает все контейнеры, работающие на этом хосте. Поэтому в сценариях с повышенными требованиями к безопасности — например, при многоарендном размещении ненадёжного кода — виртуальные машины остаются предпочтительным решением.",[46,47,49],"h3",{"id":48},"сценарии-предпочтительного-использования","Сценарии предпочтительного использования",[20,51,52],{},"Виртуальные машины предпочтительны, когда требуется запуск различных операционных систем на одном физическом сервере, когда предъявляются повышенные требования к изоляции и безопасности, а также когда приложение зависит от специфической конфигурации ядра, которая не может быть воспроизведена в контейнерной среде.",[20,54,55],{},"Контейнеры предпочтительны в сценариях, где критичны скорость развёртывания, плотность размещения и эффективность использования ресурсов: микросервисная архитектура, непрерывная интеграция и поставка, масштабирование веб-приложений.",[20,57,58],{},"На практике виртуализация и контейнеризация часто применяются совместно. Типичная архитектура облачной платформы предполагает, что контейнеры исполняются внутри виртуальных машин. Виртуальная машина обеспечивает аппаратную изоляцию между потребителями облачного сервиса, а контейнеры внутри неё обеспечивают эффективное размещение и управление прикладными компонентами.",[46,60,62],{"id":61},"сравнительная-характеристика","Сравнительная характеристика",[20,64,65],{},"По уровню изоляции виртуальные машины обеспечивают аппаратную изоляцию через гипервизор, тогда как контейнеры полагаются на механизмы ядра операционной системы. По объёму потребляемых ресурсов виртуальная машина включает полную операционную систему и потребляет от сотен мегабайт до нескольких гигабайт оперативной памяти; контейнер потребляет только ресурсы, необходимые для исполнения прикладного процесса. По времени запуска виртуальная машина загружается от десятков секунд до нескольких минут, контейнер — за секунды. По размеру артефакта образ виртуальной машины обычно измеряется гигабайтами, контейнерный образ — десятками или сотнями мегабайт. По совместимости виртуальная машина может исполнять произвольную операционную систему, тогда как контейнер ограничен ядром хостовой системы.",[67,68,69,70,69,75],"figure",{},"\n  ",[71,72],"img",{"src":73,"alt":74},"\u002Fimg\u002Faidt-bac-cloud_tech\u002Ftopic-03\u002Fvm_vs_container_stack.svg","Сравнение программных стеков: виртуальная машина и контейнер",[76,77,74],"figcaption",{},[15,79,81],{"id":80},"контейнер-и-образ-назначение-и-взаимосвязь","Контейнер и образ: назначение и взаимосвязь",[20,83,84],{},"В Docker используются две взаимосвязанные сущности: образ и контейнер. Образ — это подготовленный артефакт, который описывает, что именно будет запущено. Контейнер — это экземпляр выполнения, который определяет, как именно это будет запущено в конкретный момент времени.",[20,86,87],{},"Образ (image) представляет собой файловую систему приложения и набор метаданных запуска. В образ не входит ядро операционной системы и драйверы устройств: контейнеры используют ядро системы-хоста. Назначение образа — обеспечить переносимость и воспроизводимость: если используется один и тот же образ, приложение стартует в одинаковом наборе файлов и зависимостей (при условии совместимости архитектуры и платформы). Образ хранится локально или в реестре и может быть версионирован.",[20,89,90],{},"Контейнер (container) создаётся на основе образа и является объектом времени выполнения. При создании контейнера формируется отдельный слой файловой системы с возможностью записи, а также фиксируются параметры запуска: команда, переменные окружения, ограничения ресурсов, подключаемые хранилища и сетевые настройки. Контейнер “живёт” пока выполняется основной процесс внутри контейнера; при завершении этого процесса контейнер переходит в остановленное состояние. Поэтому контейнер — это не “отдельная операционная система”, а управляемая среда для выполнения процесса(ов) с заданной изоляцией и ресурсными ограничениями.",[67,92,69,93,69,97],{},[71,94],{"src":95,"alt":96},"\u002Fimg\u002Faidt-bac-cloud_tech\u002Ftopic-03\u002Fimage_and_container.svg","Образ и контейнер: слои только для чтения, слой записи и параметры времени выполнения",[76,98,96],{},[20,100,101],{},"Из этой модели следует ключевая практика эксплуатации. Изменения, выполненные внутри работающего контейнера, относятся к его слою записи и не являются надёжным способом сопровождения: при пересоздании контейнера они исчезают. Поэтому корректный процесс обновления приложения заключается в создании новой версии образа и запуске нового контейнера, а не во внесении изменений в уже запущенный экземпляр.",[15,103,105],{"id":104},"изоляция-контейнеров-пространства-имён-и-группы-управления-ресурсами","Изоляция контейнеров: пространства имён и группы управления ресурсами",[20,107,108],{},"Контейнеры в Linux не являются отдельными операционными системами. Это процессы, которым ядро предоставляет изолированные представления части ресурсов и одновременно применяет количественные ограничения на потребление этих ресурсов. В Docker данная модель скрыта за простым интерфейсом запуска, однако для понимания поведения контейнеров в эксплуатации важно знать, какими механизмами изоляция и ограничения реализуются.",[20,110,111],{},"Изоляция обеспечивается пространствами имён (namespaces). Пространство имён можно понимать как механизм, который заставляет процесс «видеть» только выделенный ему набор системных объектов. Например, в контейнере может быть собственная нумерация процессов, собственная конфигурация сети и отдельное дерево монтирования файловых систем. Для контейнеризации чаще всего используются несколько типов пространств имён.",[20,113,114],{},"PID namespace определяет, какие процессы видимы и как они нумеруются внутри контейнера. Благодаря этому процессы контейнера не видят процессы хоста и других контейнеров, а внутри контейнера основной процесс получает идентификатор PID 1. Этот факт имеет практические последствия: PID 1 в Linux обладает особыми обязанностями по обработке сигналов и «сборке» завершившихся дочерних процессов; поэтому некоторые приложения в роли PID 1 требуют корректной настройки, а в реальных системах нередко используют специализированные минимальные процессы-инициализаторы.",[20,116,117],{},"Network namespace предоставляет контейнеру отдельный сетевой стек: сетевые интерфейсы, таблицы маршрутизации, правила фильтрации. С точки зрения процессов внутри контейнера сеть выглядит «своей», хотя физически пакеты всё равно проходят через подсистему хоста. Именно на базе network namespaces Docker строит модели виртуальных сетей и изоляции взаимодействия между контейнерами.",[20,119,120],{},"Mount namespace формирует отдельное дерево монтирования. Это позволяет контейнеру иметь свою корневую файловую систему, собранную из слоёв образа, а также подключать дополнительные хранилища (например, тома) в заданные точки. Mount namespace тесно связан с механизмом слоистой файловой системы контейнера: процессы контейнера видят единое дерево каталогов, хотя на уровне реализации оно составлено из нескольких слоёв.",[20,122,123],{},"UTS namespace изолирует такие атрибуты, как имя хоста и доменное имя узла, что полезно для корректного поведения приложений, которые используют эти значения. IPC namespace изолирует механизмы межпроцессного взаимодействия (например, разделяемую память и семафоры), снижая риск нежелательных пересечений между контейнерами.",[20,125,126],{},"User namespace позволяет отображать идентификаторы пользователей и групп контейнера на другие идентификаторы на хосте. Это важно для безопасности: процесс может иметь высокие привилегии внутри контейнера, но соответствовать непривилегированному пользователю на хосте. На этой возможности основаны режимы запуска без прав суперпользователя (rootless), которые уменьшают последствия возможной компрометации приложения.",[20,128,129],{},"Одной из целей контейнеризации является также управляемое распределение ресурсов. Для этого ядро предоставляет механизм групп управления ресурсами (cgroups). Через cgroups можно ограничивать и учитывать потребление процессорного времени и оперативной памяти, а также собирать статистику использования ресурсов. Практическая ценность cgroups проявляется в мультисервисных системах: без ограничений один контейнер способен занять всю память или создать избыточную нагрузку на CPU и тем самым нарушить работу других сервисов. В эксплуатационной практике задавать лимиты — это способ сделать поведение системы предсказуемым и снизить влияние ошибок и пиков нагрузки.",[67,131,69,132,69,136],{},[71,133],{"src":134,"alt":135},"\u002Fimg\u002Faidt-bac-cloud_tech\u002Ftopic-03\u002Fnamespaces_cgroups_isolation.svg","Механизмы изоляции контейнера: пространства имён обеспечивают изоляцию видимости, cgroups ограничивают потребление ресурсов",[76,137,135],{},[20,139,140],{},"Важно понимать, что namespaces и cgroups решают разные задачи. Пространства имён отвечают за границы видимости и изоляцию, тогда как cgroups — за количественные ограничения и учёт. Docker объединяет оба механизма в единый объект контейнера, что и создаёт эффект «изолированной среды выполнения».",[15,142,144],{"id":143},"файловая-система-контейнера-слои-образа-слой-записи-и-внешнее-хранение-данных","Файловая система контейнера: слои образа, слой записи и внешнее хранение данных",[20,146,147],{},"Когда контейнер создаётся из образа, Docker должен предоставить процессам контейнера корневую файловую систему, которая выглядит как обычное дерево каталогов. При этом образ состоит из слоёв «только чтение», а контейнер должен иметь возможность изменять файлы в ходе работы. Эта задача решается при помощи объединённой (слоистой) файловой системы, где к слоям образа добавляется верхний слой с возможностью записи.",[20,149,150],{},"Слой записи контейнера является индивидуальным для каждого контейнера. Любые изменения файлов — создание новых, модификация существующих, удаление — фиксируются именно в этом верхнем слое. При чтении данных система формирует итоговую картину: если файл изменён, используется версия из слоя записи; если не изменён, берётся из нижних слоёв образа. Такое устройство обеспечивает быстрое развёртывание и экономию дискового пространства.",[20,152,153],{},"Вместе с тем слой записи связан с жизненным циклом контейнера. При удалении контейнера этот слой исчезает, а значит, исчезают и изменения, которые хранились только в нём. Поэтому слой записи следует рассматривать как место для временных данных и внутренних изменений, которые допускается потерять при пересоздании контейнера. Если приложению требуется постоянное хранение (данные базы, загруженные пользователями файлы, результаты вычислений), такие данные должны быть вынесены во внешнее хранилище — механизмы постоянного хранения данных в контейнерных средах подробно рассматриваются в соответствующей теме курса.",[67,155,69,156,69,160],{},[71,157],{"src":158,"alt":159},"\u002Fimg\u002Faidt-bac-cloud_tech\u002Ftopic-03\u002Flayered_filesystem.svg","Слоистая файловая система: контейнеры разделяют общие слои образа, каждый имеет собственный слой записи",[76,161,159],{},[20,163,164],{},"Слоистая файловая система влияет и на производительность. Для большинства приложений накладные расходы невелики, однако при интенсивной записи слой записи и механизмы copy-on-write могут создавать дополнительные издержки. Это обстоятельство учитывается при проектировании политики хранения данных контейнерных приложений.",[15,166,168],{"id":167},"архитектура-docker-клиент-демон-и-компоненты-исполнения","Архитектура Docker: клиент, демон и компоненты исполнения",[20,170,171],{},"Docker включает клиентскую утилиту (CLI) и серверный компонент Docker Engine (демон). Клиент направляет запросы демону, а демон управляет объектами Docker: образами, контейнерами, сетями, томами и процессом сборки. Этот подход отделяет интерфейс управления от реализации операций и позволяет централизованно вести состояние объектов.",[20,173,174],{},"На более низком уровне выполнение контейнеров делегируется специализированным компонентам. Компонент containerd отвечает за управление жизненным циклом контейнеров и взаимодействие с хранилищами образов, а runc выполняет непосредственный запуск контейнера, настраивая изоляцию через пространства имён и ограничения ресурсов через cgroups. Такое разделение упрощает поддержку и развитие системы: высокоуровневые функции управления (образы, сети, тома) отделены от механизма запуска процессов.",[67,176,69,177,69,181],{},[71,178],{"src":179,"alt":180},"\u002Fimg\u002Faidt-bac-cloud_tech\u002Ftopic-03\u002Fdocker_architecture.svg","Архитектура Docker: клиент, демон, containerd и runc",[76,182,180],{},[20,184,185],{},"Совместимость контейнерной экосистемы обеспечивается стандартами OCI (Open Container Initiative). OCI определяет формат образов и спецификацию выполнения контейнеров. Благодаря этому образы и средства запуска могут быть взаимозаменяемыми в пределах стандарта, а инфраструктура не оказывается жестко привязанной к одному программному продукту.",[15,187,189],{"id":188},"жизненный-цикл-и-базовые-операции","Жизненный цикл и базовые операции",[20,191,192],{},"Контейнер создаётся из образа, получает параметры запуска и запускает основной процесс. Контейнер считается запущенным, пока выполняется основной процесс. Это объясняет типичную ситуацию, когда контейнер “сразу останавливается”: обычно причиной является корректное завершение основного процесса, а не ошибка платформы.",[67,194,69,195,69,199],{},[71,196],{"src":197,"alt":198},"\u002Fimg\u002Faidt-bac-cloud_tech\u002Ftopic-03\u002Fcontainer_lifecycle.svg","Жизненный цикл контейнера: создание, запуск, остановка, перезапуск и удаление",[76,200,198],{},[20,202,203],{},"Docker предоставляет механизмы автоматического перезапуска контейнеров при завершении работы, однако эти механизмы являются локальными и не заменяют оркестрацию. Оркестрация решает задачи распределения экземпляров по узлам, управления обновлениями, масштабирования и восстановления при отказах — и будет рассматриваться далее в курсе.",[46,205,207],{"id":206},"журналы-и-инспекция-конфигурации","Журналы и инспекция конфигурации",[20,209,210],{},"При сопровождении контейнеров необходимо иметь доступ к журналам и к точной конфигурации запуска. В контейнерных приложениях распространена практика вывода журналов в стандартные потоки вывода, чтобы среда запуска могла централизованно собирать журнальные записи и передавать их во внешние системы мониторинга.",[20,212,213],{},"Средства инспекции предоставляют доступ к метаданным контейнера и образа: параметрам запуска, используемому образу, подключённым хранилищам, сетевым настройкам и ограничениям ресурсов. Это является основой диагностики, поскольку сбои часто связаны не с логикой приложения, а с ошибками конфигурации запуска.",[46,215,217],{"id":216},"реестры-образов","Реестры образов",[20,219,220],{},"Образы хранятся в реестрах — публичных или частных. Реестр предоставляет интерфейсы для публикации и получения образов и позволяет использовать образы как типовые артефакты поставки. Для сопровождения существенна политика версионирования: в учебных работах часто применяются теги, однако в эксплуатационных сценариях предпочтительнее исключать неоднозначность и фиксировать конкретные версии (включая возможность использования идентификатора содержимого).",[20,222,223],{},"В реальных системах реестр выступает частью цепочки поставки: он позволяет централизованно хранить утверждённые версии образов, управлять доступом и проводить дополнительные проверки (например, сканирование на уязвимости). Эти вопросы будут подробно рассмотрены в главах, посвящённых безопасности и сопровождению.",[15,225,227],{"id":226},"итоги-темы","Итоги темы",[20,229,230],{},"Контейнеризация представляет собой модель изоляции процессов, основанную на механизмах ядра операционной системы — пространствах имён и группах управления ресурсами. В отличие от виртуальных машин, контейнеры разделяют ядро хоста, что обеспечивает существенное сокращение времени запуска и накладных расходов. Docker предоставляет единую модель управления контейнерами, образами, сетями и томами, опираясь на стандарты OCI для обеспечения переносимости. Образ выступает неизменяемым артефактом поставки, а контейнер — его экземпляром времени выполнения с эфемерным слоем записи. Понимание границ контейнерной изоляции, слоистой файловой системы и жизненного цикла контейнера является необходимым основанием для последующего изучения сборки образов, сетевого взаимодействия и оркестрации.",{"title":232,"searchDepth":233,"depth":233,"links":234},"",2,[235,236,241,242,243,244,245,249],{"id":17,"depth":233,"text":18},{"id":31,"depth":233,"text":32,"children":237},[238,240],{"id":48,"depth":239,"text":49},3,{"id":61,"depth":239,"text":62},{"id":80,"depth":233,"text":81},{"id":104,"depth":233,"text":105},{"id":143,"depth":233,"text":144},{"id":167,"depth":233,"text":168},{"id":188,"depth":233,"text":189,"children":246},[247,248],{"id":206,"depth":239,"text":207},{"id":216,"depth":239,"text":217},{"id":226,"depth":233,"text":227},"aidt-bac-cloud_tech",null,"md",false,{},true,"\u002Fcourses\u002Faidt-bac-cloud_tech\u002Ftopic-03-content","content",{"title":6,"description":232},"courses\u002Faidt-bac-cloud_tech\u002Ftopic-03-content","topic-03","ZyJtUa8xGYg0lo1hI-6krFfp4f1mafXJcE-3W8IB-WI",{"id":263,"title":264,"body":265,"course_slug":250,"description":232,"env_label":251,"env_url":251,"extension":252,"group":251,"is_course_project":253,"is_index":253,"level":251,"meta":1641,"navigation":255,"path":1642,"section":1643,"seo":1644,"stem":1645,"topic_number":239,"topic_slug":260,"__hash__":1646},"courses\u002Fcourses\u002Faidt-bac-cloud_tech\u002Ftopic-03-lr.md","Лабораторная работа 3. Контейнеризация и архитектура Docker",{"type":8,"value":266,"toc":1629},[267,270,274,277,281,284,287,309,312,315,319,322,326,332,422,432,436,439,443,743,748,752,755,759,1099,1104,1108,1111,1115,1558,1563,1567,1570,1587,1590,1594,1625],[11,268,264],{"id":269},"лабораторная-работа-3-контейнеризация-и-архитектура-docker",[15,271,273],{"id":272},"цель-работы","Цель работы",[20,275,276],{},"Получить практические навыки установки и использования Docker как среды контейнеризации. Исследовать жизненный цикл контейнера, механизмы изоляции и слоистую файловую систему. Убедиться в различиях между образом и контейнером на конкретных примерах и сопоставить поведение контейнерной среды с виртуальной машиной, изученной в предыдущей лабораторной работе.",[15,278,280],{"id":279},"предварительные-сведения","Предварительные сведения",[20,282,283],{},"Для выполнения лабораторной работы потребуется компьютер с операционной системой Windows 10\u002F11 (с WSL 2), macOS 12+ или Linux (Ubuntu 22.04+ или аналогичный дистрибутив). На рабочем месте должен быть установлен Docker Engine версии 24.0 или новее (на Linux) либо Docker Desktop (на Windows и macOS).",[20,285,286],{},"Проверка готовности среды выполняется командой:",[288,289,293],"pre",{"className":290,"code":291,"language":292,"meta":232,"style":232},"language-bash shiki shiki-themes github-light github-dark","docker version\n","bash",[294,295,296],"code",{"__ignoreMap":232},[297,298,301,305],"span",{"class":299,"line":300},"line",1,[297,302,304],{"class":303},"sScJk","docker",[297,306,308],{"class":307},"sZZnC"," version\n",[20,310,311],{},"Команда должна вывести информацию о клиенте и сервере Docker. Если сервер недоступен, убедитесь, что демон Docker запущен.",[20,313,314],{},"Работа выполняется на локальной машине студента и не требует подключения к облачным платформам. Основным результатом является отчёт, содержащий описание проделанных действий, вывод команд, наблюдения и ответы на поставленные вопросы.",[15,316,318],{"id":317},"задание","Задание",[20,320,321],{},"Работа состоит из четырёх последовательных частей.",[46,323,325],{"id":324},"часть-1-установка-docker-и-проверка-среды-контейнеризации","Часть 1. Установка Docker и проверка среды контейнеризации",[20,327,328],{},[329,330,331],"strong",{},"Порядок выполнения:",[333,334,335,339,378,400],"ol",{},[336,337,338],"li",{},"Установите Docker, следуя официальной документации для вашей операционной системы. Зафиксируйте в отчёте версию Docker Engine и версию операционной системы хоста.",[336,340,341,342],{},"Выполните следующие команды и зафиксируйте их вывод:",[288,343,345],{"className":290,"code":344,"language":292,"meta":232,"style":232},"# Версия Docker и сведения о среде\ndocker version\n\n# Подробная информация о конфигурации Docker Engine\ndocker info\n",[294,346,347,353,359,364,370],{"__ignoreMap":232},[297,348,349],{"class":299,"line":300},[297,350,352],{"class":351},"sJ8bj","# Версия Docker и сведения о среде\n",[297,354,355,357],{"class":299,"line":233},[297,356,304],{"class":303},[297,358,308],{"class":307},[297,360,361],{"class":299,"line":239},[297,362,363],{"emptyLinePlaceholder":255},"\n",[297,365,367],{"class":299,"line":366},4,[297,368,369],{"class":351},"# Подробная информация о конфигурации Docker Engine\n",[297,371,373,375],{"class":299,"line":372},5,[297,374,304],{"class":303},[297,376,377],{"class":307}," info\n",[336,379,380,381,384,385],{},"В выводе команды ",[294,382,383],{},"docker info"," найдите и зафиксируйте в отчёте:",[386,387,388,391,394,397],"ul",{},[336,389,390],{},"используемый драйвер хранилища (Storage Driver);",[336,392,393],{},"среду выполнения контейнеров (Default Runtime);",[336,395,396],{},"корневой каталог Docker (Docker Root Dir);",[336,398,399],{},"количество контейнеров и образов в системе.",[336,401,402,403,418,421],{},"Запустите тестовый контейнер для проверки работоспособности среды:",[288,404,406],{"className":290,"code":405,"language":292,"meta":232,"style":232},"docker run hello-world\n",[294,407,408],{"__ignoreMap":232},[297,409,410,412,415],{"class":299,"line":300},[297,411,304],{"class":303},[297,413,414],{"class":307}," run",[297,416,417],{"class":307}," hello-world\n",[419,420],"br",{},"Убедитесь, что вывод содержит сообщение об успешном выполнении. Объясните в отчёте, какие шаги выполнил Docker при обработке этой команды (откуда был получен образ, что произошло после его загрузки, почему контейнер завершился).",[20,423,424,427,428,431],{},[329,425,426],{},"Результат:"," работающая среда Docker, зафиксированные параметры конфигурации, объяснение выполнения ",[294,429,430],{},"docker run hello-world",".",[46,433,435],{"id":434},"часть-2-жизненный-цикл-контейнера","Часть 2. Жизненный цикл контейнера",[20,437,438],{},"Цель части — исследовать состояния контейнера, роль основного процесса (PID 1) и механизмы управления жизненным циклом.",[20,440,441],{},[329,442,331],{},[333,444,445,478,500,572,669,715],{},[336,446,447,448],{},"Запустите контейнер с веб-сервером Nginx в фоновом режиме:",[288,449,451],{"className":290,"code":450,"language":292,"meta":232,"style":232},"docker run -d --name web-server -p 8080:80 nginx:1.27\n",[294,452,453],{"__ignoreMap":232},[297,454,455,457,459,463,466,469,472,475],{"class":299,"line":300},[297,456,304],{"class":303},[297,458,414],{"class":307},[297,460,462],{"class":461},"sj4cs"," -d",[297,464,465],{"class":461}," --name",[297,467,468],{"class":307}," web-server",[297,470,471],{"class":461}," -p",[297,473,474],{"class":307}," 8080:80",[297,476,477],{"class":307}," nginx:1.27\n",[336,479,480,481,493,495,496,499],{},"Убедитесь, что контейнер работает, и зафиксируйте его состояние:",[288,482,484],{"className":290,"code":483,"language":292,"meta":232,"style":232},"docker ps\n",[294,485,486],{"__ignoreMap":232},[297,487,488,490],{"class":299,"line":300},[297,489,304],{"class":303},[297,491,492],{"class":307}," ps\n",[419,494],{},"Откройте в браузере адрес ",[294,497,498],{},"http:\u002F\u002Flocalhost:8080"," и убедитесь, что отображается стартовая страница Nginx.",[336,501,502,503,565,567,568,571],{},"Исследуйте информацию о контейнере:",[288,504,506],{"className":290,"code":505,"language":292,"meta":232,"style":232},"# Подробная конфигурация контейнера\ndocker inspect web-server\n\n# Журналы контейнера\ndocker logs web-server\n\n# Потребление ресурсов в реальном времени\ndocker stats web-server --no-stream\n",[294,507,508,513,523,527,532,541,546,552],{"__ignoreMap":232},[297,509,510],{"class":299,"line":300},[297,511,512],{"class":351},"# Подробная конфигурация контейнера\n",[297,514,515,517,520],{"class":299,"line":233},[297,516,304],{"class":303},[297,518,519],{"class":307}," inspect",[297,521,522],{"class":307}," web-server\n",[297,524,525],{"class":299,"line":239},[297,526,363],{"emptyLinePlaceholder":255},[297,528,529],{"class":299,"line":366},[297,530,531],{"class":351},"# Журналы контейнера\n",[297,533,534,536,539],{"class":299,"line":372},[297,535,304],{"class":303},[297,537,538],{"class":307}," logs",[297,540,522],{"class":307},[297,542,544],{"class":299,"line":543},6,[297,545,363],{"emptyLinePlaceholder":255},[297,547,549],{"class":299,"line":548},7,[297,550,551],{"class":351},"# Потребление ресурсов в реальном времени\n",[297,553,555,557,560,562],{"class":299,"line":554},8,[297,556,304],{"class":303},[297,558,559],{"class":307}," stats",[297,561,468],{"class":307},[297,563,564],{"class":461}," --no-stream\n",[419,566],{},"Из вывода ",[294,569,570],{},"docker inspect"," найдите и зафиксируйте в отчёте: используемый образ, IP-адрес контейнера, проброшенные порты, команду запуска (Cmd или Entrypoint).",[336,573,574,575,663,665,666,668],{},"Исследуйте переходы между состояниями контейнера:",[288,576,578],{"className":290,"code":577,"language":292,"meta":232,"style":232},"# Остановка контейнера\ndocker stop web-server\ndocker ps -a\n\n# Повторный запуск\ndocker start web-server\ndocker ps\n\n# Перезапуск\ndocker restart web-server\ndocker logs web-server --tail 5\n",[294,579,580,585,594,604,608,613,622,628,632,638,648],{"__ignoreMap":232},[297,581,582],{"class":299,"line":300},[297,583,584],{"class":351},"# Остановка контейнера\n",[297,586,587,589,592],{"class":299,"line":233},[297,588,304],{"class":303},[297,590,591],{"class":307}," stop",[297,593,522],{"class":307},[297,595,596,598,601],{"class":299,"line":239},[297,597,304],{"class":303},[297,599,600],{"class":307}," ps",[297,602,603],{"class":461}," -a\n",[297,605,606],{"class":299,"line":366},[297,607,363],{"emptyLinePlaceholder":255},[297,609,610],{"class":299,"line":372},[297,611,612],{"class":351},"# Повторный запуск\n",[297,614,615,617,620],{"class":299,"line":543},[297,616,304],{"class":303},[297,618,619],{"class":307}," start",[297,621,522],{"class":307},[297,623,624,626],{"class":299,"line":548},[297,625,304],{"class":303},[297,627,492],{"class":307},[297,629,630],{"class":299,"line":554},[297,631,363],{"emptyLinePlaceholder":255},[297,633,635],{"class":299,"line":634},9,[297,636,637],{"class":351},"# Перезапуск\n",[297,639,641,643,646],{"class":299,"line":640},10,[297,642,304],{"class":303},[297,644,645],{"class":307}," restart",[297,647,522],{"class":307},[297,649,651,653,655,657,660],{"class":299,"line":650},11,[297,652,304],{"class":303},[297,654,538],{"class":307},[297,656,468],{"class":307},[297,658,659],{"class":461}," --tail",[297,661,662],{"class":461}," 5\n",[419,664],{},"Зафиксируйте, как изменяется состояние контейнера (столбец STATUS) после каждой операции. Проверьте, сохраняется ли доступность ",[294,667,498],{}," после перезапуска.",[336,670,671,672,712,714],{},"Исследуйте поведение контейнера при завершении основного процесса. Запустите контейнер, основной процесс которого завершается немедленно:",[288,673,675],{"className":290,"code":674,"language":292,"meta":232,"style":232},"docker run --name instant-exit ubuntu:24.04 echo \"Процесс завершён\"\ndocker ps -a --filter name=instant-exit\n",[294,676,677,697],{"__ignoreMap":232},[297,678,679,681,683,685,688,691,694],{"class":299,"line":300},[297,680,304],{"class":303},[297,682,414],{"class":307},[297,684,465],{"class":461},[297,686,687],{"class":307}," instant-exit",[297,689,690],{"class":307}," ubuntu:24.04",[297,692,693],{"class":307}," echo",[297,695,696],{"class":307}," \"Процесс завершён\"\n",[297,698,699,701,703,706,709],{"class":299,"line":233},[297,700,304],{"class":303},[297,702,600],{"class":307},[297,704,705],{"class":461}," -a",[297,707,708],{"class":461}," --filter",[297,710,711],{"class":307}," name=instant-exit\n",[419,713],{},"Зафиксируйте статус контейнера. Объясните в отчёте, почему контейнер перешёл в состояние Exited, и сопоставьте это поведение с контейнером Nginx, который продолжает работать.",[336,716,717,718],{},"Выполните очистку:",[288,719,721],{"className":290,"code":720,"language":292,"meta":232,"style":232},"docker stop web-server\ndocker rm web-server instant-exit\n",[294,722,723,731],{"__ignoreMap":232},[297,724,725,727,729],{"class":299,"line":300},[297,726,304],{"class":303},[297,728,591],{"class":307},[297,730,522],{"class":307},[297,732,733,735,738,740],{"class":299,"line":233},[297,734,304],{"class":303},[297,736,737],{"class":307}," rm",[297,739,468],{"class":307},[297,741,742],{"class":307}," instant-exit\n",[20,744,745,747],{},[329,746,426],{}," зафиксированные переходы между состояниями, вывод команд инспекции, объяснение роли основного процесса.",[46,749,751],{"id":750},"часть-3-образ-и-контейнер-слоистая-файловая-система-и-эфемерность","Часть 3. Образ и контейнер: слоистая файловая система и эфемерность",[20,753,754],{},"Цель части — убедиться на практике в различии между образом (неизменяемый артефакт) и контейнером (эфемерный экземпляр выполнения со слоем записи).",[20,756,757],{},[329,758,331],{},[333,760,761,817,855,933,1050,1071],{},[336,762,763,764,814,816],{},"Загрузите образ и исследуйте его слои:",[288,765,767],{"className":290,"code":766,"language":292,"meta":232,"style":232},"docker pull nginx:1.27\n\n# Список слоёв образа\ndocker history nginx:1.27\n\n# Размер образа\ndocker images nginx:1.27\n",[294,768,769,778,782,787,796,800,805],{"__ignoreMap":232},[297,770,771,773,776],{"class":299,"line":300},[297,772,304],{"class":303},[297,774,775],{"class":307}," pull",[297,777,477],{"class":307},[297,779,780],{"class":299,"line":233},[297,781,363],{"emptyLinePlaceholder":255},[297,783,784],{"class":299,"line":239},[297,785,786],{"class":351},"# Список слоёв образа\n",[297,788,789,791,794],{"class":299,"line":366},[297,790,304],{"class":303},[297,792,793],{"class":307}," history",[297,795,477],{"class":307},[297,797,798],{"class":299,"line":372},[297,799,363],{"emptyLinePlaceholder":255},[297,801,802],{"class":299,"line":543},[297,803,804],{"class":351},"# Размер образа\n",[297,806,807,809,812],{"class":299,"line":548},[297,808,304],{"class":303},[297,810,811],{"class":307}," images",[297,813,477],{"class":307},[419,815],{},"Зафиксируйте количество слоёв и общий размер образа.",[336,818,819,820],{},"Создайте два контейнера из одного образа и убедитесь, что они разделяют слои:",[288,821,823],{"className":290,"code":822,"language":292,"meta":232,"style":232},"docker run -d --name container-a nginx:1.27\ndocker run -d --name container-b nginx:1.27\n",[294,824,825,840],{"__ignoreMap":232},[297,826,827,829,831,833,835,838],{"class":299,"line":300},[297,828,304],{"class":303},[297,830,414],{"class":307},[297,832,462],{"class":461},[297,834,465],{"class":461},[297,836,837],{"class":307}," container-a",[297,839,477],{"class":307},[297,841,842,844,846,848,850,853],{"class":299,"line":233},[297,843,304],{"class":303},[297,845,414],{"class":307},[297,847,462],{"class":461},[297,849,465],{"class":461},[297,851,852],{"class":307}," container-b",[297,854,477],{"class":307},[336,856,857,858,930,932],{},"Внесите изменение в файловую систему первого контейнера и проверьте, затронут ли второй:",[288,859,861],{"className":290,"code":860,"language":292,"meta":232,"style":232},"# Создайте файл в контейнере A\ndocker exec container-a bash -c \"echo 'Контейнер A' > \u002Ftmp\u002Ftest.txt\"\n\n# Проверьте наличие файла в контейнере A\ndocker exec container-a cat \u002Ftmp\u002Ftest.txt\n\n# Проверьте наличие файла в контейнере B\ndocker exec container-b cat \u002Ftmp\u002Ftest.txt\n",[294,862,863,868,886,890,895,909,913,918],{"__ignoreMap":232},[297,864,865],{"class":299,"line":300},[297,866,867],{"class":351},"# Создайте файл в контейнере A\n",[297,869,870,872,875,877,880,883],{"class":299,"line":233},[297,871,304],{"class":303},[297,873,874],{"class":307}," exec",[297,876,837],{"class":307},[297,878,879],{"class":307}," bash",[297,881,882],{"class":461}," -c",[297,884,885],{"class":307}," \"echo 'Контейнер A' > \u002Ftmp\u002Ftest.txt\"\n",[297,887,888],{"class":299,"line":239},[297,889,363],{"emptyLinePlaceholder":255},[297,891,892],{"class":299,"line":366},[297,893,894],{"class":351},"# Проверьте наличие файла в контейнере A\n",[297,896,897,899,901,903,906],{"class":299,"line":372},[297,898,304],{"class":303},[297,900,874],{"class":307},[297,902,837],{"class":307},[297,904,905],{"class":307}," cat",[297,907,908],{"class":307}," \u002Ftmp\u002Ftest.txt\n",[297,910,911],{"class":299,"line":543},[297,912,363],{"emptyLinePlaceholder":255},[297,914,915],{"class":299,"line":548},[297,916,917],{"class":351},"# Проверьте наличие файла в контейнере B\n",[297,919,920,922,924,926,928],{"class":299,"line":554},[297,921,304],{"class":303},[297,923,874],{"class":307},[297,925,852],{"class":307},[297,927,905],{"class":307},[297,929,908],{"class":307},[419,931],{},"Зафиксируйте результат. Объясните, почему файл, созданный в контейнере A, не виден в контейнере B, хотя оба контейнера созданы из одного образа.",[336,934,935,936,1047,1049],{},"Проверьте эфемерность слоя записи:",[288,937,939],{"className":290,"code":938,"language":292,"meta":232,"style":232},"# Модифицируйте стартовую страницу Nginx в контейнере A\ndocker exec container-a bash -c \"echo '\u003Ch1>Изменённая страница\u003C\u002Fh1>' > \u002Fusr\u002Fshare\u002Fnginx\u002Fhtml\u002Findex.html\"\n\n# Убедитесь, что изменение действует\ndocker exec container-a cat \u002Fusr\u002Fshare\u002Fnginx\u002Fhtml\u002Findex.html\n\n# Удалите контейнер A и создайте новый из того же образа\ndocker stop container-a\ndocker rm container-a\ndocker run -d --name container-a-new nginx:1.27\n\n# Проверьте содержимое стартовой страницы в новом контейнере\ndocker exec container-a-new cat \u002Fusr\u002Fshare\u002Fnginx\u002Fhtml\u002Findex.html\n",[294,940,941,946,961,965,970,983,987,992,1001,1009,1024,1028,1034],{"__ignoreMap":232},[297,942,943],{"class":299,"line":300},[297,944,945],{"class":351},"# Модифицируйте стартовую страницу Nginx в контейнере A\n",[297,947,948,950,952,954,956,958],{"class":299,"line":233},[297,949,304],{"class":303},[297,951,874],{"class":307},[297,953,837],{"class":307},[297,955,879],{"class":307},[297,957,882],{"class":461},[297,959,960],{"class":307}," \"echo '\u003Ch1>Изменённая страница\u003C\u002Fh1>' > \u002Fusr\u002Fshare\u002Fnginx\u002Fhtml\u002Findex.html\"\n",[297,962,963],{"class":299,"line":239},[297,964,363],{"emptyLinePlaceholder":255},[297,966,967],{"class":299,"line":366},[297,968,969],{"class":351},"# Убедитесь, что изменение действует\n",[297,971,972,974,976,978,980],{"class":299,"line":372},[297,973,304],{"class":303},[297,975,874],{"class":307},[297,977,837],{"class":307},[297,979,905],{"class":307},[297,981,982],{"class":307}," \u002Fusr\u002Fshare\u002Fnginx\u002Fhtml\u002Findex.html\n",[297,984,985],{"class":299,"line":543},[297,986,363],{"emptyLinePlaceholder":255},[297,988,989],{"class":299,"line":548},[297,990,991],{"class":351},"# Удалите контейнер A и создайте новый из того же образа\n",[297,993,994,996,998],{"class":299,"line":554},[297,995,304],{"class":303},[297,997,591],{"class":307},[297,999,1000],{"class":307}," container-a\n",[297,1002,1003,1005,1007],{"class":299,"line":634},[297,1004,304],{"class":303},[297,1006,737],{"class":307},[297,1008,1000],{"class":307},[297,1010,1011,1013,1015,1017,1019,1022],{"class":299,"line":640},[297,1012,304],{"class":303},[297,1014,414],{"class":307},[297,1016,462],{"class":461},[297,1018,465],{"class":461},[297,1020,1021],{"class":307}," container-a-new",[297,1023,477],{"class":307},[297,1025,1026],{"class":299,"line":650},[297,1027,363],{"emptyLinePlaceholder":255},[297,1029,1031],{"class":299,"line":1030},12,[297,1032,1033],{"class":351},"# Проверьте содержимое стартовой страницы в новом контейнере\n",[297,1035,1037,1039,1041,1043,1045],{"class":299,"line":1036},13,[297,1038,304],{"class":303},[297,1040,874],{"class":307},[297,1042,1021],{"class":307},[297,1044,905],{"class":307},[297,1046,982],{"class":307},[419,1048],{},"Зафиксируйте, сохранилось ли изменение. Объясните результат, опираясь на понятия слоя записи и неизменяемости образа.",[336,1051,1052,1053,1068,1070],{},"Исследуйте разницу в дисковом пространстве между образом и контейнерами:",[288,1054,1056],{"className":290,"code":1055,"language":292,"meta":232,"style":232},"docker system df\n",[294,1057,1058],{"__ignoreMap":232},[297,1059,1060,1062,1065],{"class":299,"line":300},[297,1061,304],{"class":303},[297,1063,1064],{"class":307}," system",[297,1066,1067],{"class":307}," df\n",[419,1069],{},"Зафиксируйте, сколько дискового пространства занимают образы и сколько — контейнеры. Объясните, почему два контейнера из одного образа занимают существенно меньше места, чем два копии образа.",[336,1072,717,1073],{},[288,1074,1076],{"className":290,"code":1075,"language":292,"meta":232,"style":232},"docker stop container-b container-a-new\ndocker rm container-b container-a-new\n",[294,1077,1078,1089],{"__ignoreMap":232},[297,1079,1080,1082,1084,1086],{"class":299,"line":300},[297,1081,304],{"class":303},[297,1083,591],{"class":307},[297,1085,852],{"class":307},[297,1087,1088],{"class":307}," container-a-new\n",[297,1090,1091,1093,1095,1097],{"class":299,"line":233},[297,1092,304],{"class":303},[297,1094,737],{"class":307},[297,1096,852],{"class":307},[297,1098,1088],{"class":307},[20,1100,1101,1103],{},[329,1102,426],{}," зафиксированные эксперименты с файловой системой, объяснение механизма слоёв, ответы на поставленные вопросы.",[46,1105,1107],{"id":1106},"часть-4-механизмы-изоляции-контейнера","Часть 4. Механизмы изоляции контейнера",[20,1109,1110],{},"Цель части — наблюдать работу пространств имён и ограничений ресурсов на практике, а также сопоставить изоляцию контейнера с изоляцией виртуальной машины из предыдущей лабораторной работы.",[20,1112,1113],{},[329,1114,331],{},[333,1116,1117,1258,1298,1361,1431,1520],{},[336,1118,1119,1120,1144,1146,1147,1252,1254,1255,431],{},"Запустите контейнер в интерактивном режиме и исследуйте его представление о системе:",[288,1121,1123],{"className":290,"code":1122,"language":292,"meta":232,"style":232},"docker run -it --name isolation-test ubuntu:24.04 bash\n",[294,1124,1125],{"__ignoreMap":232},[297,1126,1127,1129,1131,1134,1136,1139,1141],{"class":299,"line":300},[297,1128,304],{"class":303},[297,1130,414],{"class":307},[297,1132,1133],{"class":461}," -it",[297,1135,465],{"class":461},[297,1137,1138],{"class":307}," isolation-test",[297,1140,690],{"class":307},[297,1142,1143],{"class":307}," bash\n",[419,1145],{},"Внутри контейнера выполните следующие команды и зафиксируйте вывод:",[288,1148,1150],{"className":290,"code":1149,"language":292,"meta":232,"style":232},"# Имя хоста (UTS namespace)\nhostname\n\n# Список процессов (PID namespace)\nps aux\n\n# Сетевые интерфейсы (Network namespace)\nip address show\n# (если ip недоступна: cat \u002Fproc\u002Fnet\u002Fif_inet6 или hostname -I)\n\n# Идентификатор текущего пользователя (User namespace)\nid\nwhoami\n\n# Корневая файловая система (Mount namespace)\nls \u002F\ncat \u002Fetc\u002Fos-release\n",[294,1151,1152,1157,1162,1166,1171,1179,1183,1188,1199,1204,1208,1213,1218,1223,1228,1234,1243],{"__ignoreMap":232},[297,1153,1154],{"class":299,"line":300},[297,1155,1156],{"class":351},"# Имя хоста (UTS namespace)\n",[297,1158,1159],{"class":299,"line":233},[297,1160,1161],{"class":303},"hostname\n",[297,1163,1164],{"class":299,"line":239},[297,1165,363],{"emptyLinePlaceholder":255},[297,1167,1168],{"class":299,"line":366},[297,1169,1170],{"class":351},"# Список процессов (PID namespace)\n",[297,1172,1173,1176],{"class":299,"line":372},[297,1174,1175],{"class":303},"ps",[297,1177,1178],{"class":307}," aux\n",[297,1180,1181],{"class":299,"line":543},[297,1182,363],{"emptyLinePlaceholder":255},[297,1184,1185],{"class":299,"line":548},[297,1186,1187],{"class":351},"# Сетевые интерфейсы (Network namespace)\n",[297,1189,1190,1193,1196],{"class":299,"line":554},[297,1191,1192],{"class":303},"ip",[297,1194,1195],{"class":307}," address",[297,1197,1198],{"class":307}," show\n",[297,1200,1201],{"class":299,"line":634},[297,1202,1203],{"class":351},"# (если ip недоступна: cat \u002Fproc\u002Fnet\u002Fif_inet6 или hostname -I)\n",[297,1205,1206],{"class":299,"line":640},[297,1207,363],{"emptyLinePlaceholder":255},[297,1209,1210],{"class":299,"line":650},[297,1211,1212],{"class":351},"# Идентификатор текущего пользователя (User namespace)\n",[297,1214,1215],{"class":299,"line":1030},[297,1216,1217],{"class":303},"id\n",[297,1219,1220],{"class":299,"line":1036},[297,1221,1222],{"class":303},"whoami\n",[297,1224,1226],{"class":299,"line":1225},14,[297,1227,363],{"emptyLinePlaceholder":255},[297,1229,1231],{"class":299,"line":1230},15,[297,1232,1233],{"class":351},"# Корневая файловая система (Mount namespace)\n",[297,1235,1237,1240],{"class":299,"line":1236},16,[297,1238,1239],{"class":303},"ls",[297,1241,1242],{"class":307}," \u002F\n",[297,1244,1246,1249],{"class":299,"line":1245},17,[297,1247,1248],{"class":303},"cat",[297,1250,1251],{"class":307}," \u002Fetc\u002Fos-release\n",[419,1253],{},"Выйдите из контейнера командой ",[294,1256,1257],{},"exit",[336,1259,1260,1261,1295,1297],{},"Сопоставьте наблюдения с хостовой системой. На хосте выполните:",[288,1262,1264],{"className":290,"code":1263,"language":292,"meta":232,"style":232},"hostname\nps aux | head -20\nip address show\n",[294,1265,1266,1270,1287],{"__ignoreMap":232},[297,1267,1268],{"class":299,"line":300},[297,1269,1161],{"class":303},[297,1271,1272,1274,1277,1281,1284],{"class":299,"line":233},[297,1273,1175],{"class":303},[297,1275,1276],{"class":307}," aux",[297,1278,1280],{"class":1279},"szBVR"," |",[297,1282,1283],{"class":303}," head",[297,1285,1286],{"class":461}," -20\n",[297,1288,1289,1291,1293],{"class":299,"line":239},[297,1290,1192],{"class":303},[297,1292,1195],{"class":307},[297,1294,1198],{"class":307},[419,1296],{},"Зафиксируйте, какие различия видны между представлением контейнера и хоста. Объясните, какие пространства имён отвечают за каждое из наблюдаемых различий.",[336,1299,1300,1301,1342,1344,1345,1358,1360],{},"Исследуйте ограничение ресурсов через cgroups. Запустите два контейнера с различными лимитами памяти:",[288,1302,1304],{"className":290,"code":1303,"language":292,"meta":232,"style":232},"docker run -d --name limited-256 --memory=256m nginx:1.27\ndocker run -d --name limited-128 --memory=128m nginx:1.27\n",[294,1305,1306,1324],{"__ignoreMap":232},[297,1307,1308,1310,1312,1314,1316,1319,1322],{"class":299,"line":300},[297,1309,304],{"class":303},[297,1311,414],{"class":307},[297,1313,462],{"class":461},[297,1315,465],{"class":461},[297,1317,1318],{"class":307}," limited-256",[297,1320,1321],{"class":461}," --memory=256m",[297,1323,477],{"class":307},[297,1325,1326,1328,1330,1332,1334,1337,1340],{"class":299,"line":233},[297,1327,304],{"class":303},[297,1329,414],{"class":307},[297,1331,462],{"class":461},[297,1333,465],{"class":461},[297,1335,1336],{"class":307}," limited-128",[297,1338,1339],{"class":461}," --memory=128m",[297,1341,477],{"class":307},[419,1343],{},"Проверьте действующие ограничения:",[288,1346,1348],{"className":290,"code":1347,"language":292,"meta":232,"style":232},"docker stats --no-stream\n",[294,1349,1350],{"__ignoreMap":232},[297,1351,1352,1354,1356],{"class":299,"line":300},[297,1353,304],{"class":303},[297,1355,559],{"class":307},[297,1357,564],{"class":461},[419,1359],{},"Зафиксируйте столбцы MEM USAGE \u002F LIMIT для каждого контейнера. Убедитесь, что ограничения соответствуют заданным параметрам.",[336,1362,1363,1364,1428,1430],{},"Проверьте реакцию на превышение лимита памяти:",[288,1365,1367],{"className":290,"code":1366,"language":292,"meta":232,"style":232},"# Запустите контейнер с жёстким ограничением памяти в 8 МБ\ndocker run -d --name oom-test --memory=8m nginx:1.27\n\n# Через несколько секунд проверьте состояние контейнера\ndocker ps -a --filter name=oom-test\ndocker inspect oom-test --format='{{.State.OOMKilled}}'\n",[294,1368,1369,1374,1392,1396,1401,1414],{"__ignoreMap":232},[297,1370,1371],{"class":299,"line":300},[297,1372,1373],{"class":351},"# Запустите контейнер с жёстким ограничением памяти в 8 МБ\n",[297,1375,1376,1378,1380,1382,1384,1387,1390],{"class":299,"line":233},[297,1377,304],{"class":303},[297,1379,414],{"class":307},[297,1381,462],{"class":461},[297,1383,465],{"class":461},[297,1385,1386],{"class":307}," oom-test",[297,1388,1389],{"class":461}," --memory=8m",[297,1391,477],{"class":307},[297,1393,1394],{"class":299,"line":239},[297,1395,363],{"emptyLinePlaceholder":255},[297,1397,1398],{"class":299,"line":366},[297,1399,1400],{"class":351},"# Через несколько секунд проверьте состояние контейнера\n",[297,1402,1403,1405,1407,1409,1411],{"class":299,"line":372},[297,1404,304],{"class":303},[297,1406,600],{"class":307},[297,1408,705],{"class":461},[297,1410,708],{"class":461},[297,1412,1413],{"class":307}," name=oom-test\n",[297,1415,1416,1418,1420,1422,1425],{"class":299,"line":543},[297,1417,304],{"class":303},[297,1419,519],{"class":307},[297,1421,1386],{"class":307},[297,1423,1424],{"class":461}," --format=",[297,1426,1427],{"class":307},"'{{.State.OOMKilled}}'\n",[419,1429],{},"Зафиксируйте, завершился ли контейнер аварийно (OOMKilled). Если контейнер продолжает работать, постепенно уменьшайте лимит. Объясните в отчёте механизм OOM Killer и его связь с cgroups.",[336,1432,1433,1434],{},"Заполните сравнительную таблицу на основании наблюдений из текущей и предыдущей лабораторной работы:",[1435,1436,1437,1453],"table",{},[1438,1439,1440],"thead",{},[1441,1442,1443,1447,1450],"tr",{},[1444,1445,1446],"th",{},"Характеристика",[1444,1448,1449],{},"Виртуальная машина (VirtualBox)",[1444,1451,1452],{},"Контейнер (Docker)",[1454,1455,1456,1466,1475,1484,1493,1502,1511],"tbody",{},[1441,1457,1458,1462,1464],{},[1459,1460,1461],"td",{},"Наличие собственного ядра ОС",[1459,1463],{},[1459,1465],{},[1441,1467,1468,1471,1473],{},[1459,1469,1470],{},"Время запуска среды",[1459,1472],{},[1459,1474],{},[1441,1476,1477,1480,1482],{},[1459,1478,1479],{},"Механизм изоляции процессов",[1459,1481],{},[1459,1483],{},[1441,1485,1486,1489,1491],{},[1459,1487,1488],{},"Механизм изоляции сети",[1459,1490],{},[1459,1492],{},[1441,1494,1495,1498,1500],{},[1459,1496,1497],{},"Видимость процессов с хоста",[1459,1499],{},[1459,1501],{},[1441,1503,1504,1507,1509],{},[1459,1505,1506],{},"Накладные расходы на дисковое пространство",[1459,1508],{},[1459,1510],{},[1441,1512,1513,1516,1518],{},[1459,1514,1515],{},"Ограничение потребления памяти",[1459,1517],{},[1459,1519],{},[336,1521,717,1522],{},[288,1523,1525],{"className":290,"code":1524,"language":292,"meta":232,"style":232},"docker rm -f isolation-test limited-256 limited-128 oom-test\ndocker image prune -f\n",[294,1526,1527,1545],{"__ignoreMap":232},[297,1528,1529,1531,1533,1536,1538,1540,1542],{"class":299,"line":300},[297,1530,304],{"class":303},[297,1532,737],{"class":307},[297,1534,1535],{"class":461}," -f",[297,1537,1138],{"class":307},[297,1539,1318],{"class":307},[297,1541,1336],{"class":307},[297,1543,1544],{"class":307}," oom-test\n",[297,1546,1547,1549,1552,1555],{"class":299,"line":233},[297,1548,304],{"class":303},[297,1550,1551],{"class":307}," image",[297,1553,1554],{"class":307}," prune",[297,1556,1557],{"class":461}," -f\n",[20,1559,1560,1562],{},[329,1561,426],{}," зафиксированные наблюдения по каждому типу изоляции, заполненная сравнительная таблица, объяснение механизмов pространств имён и cgroups.",[15,1564,1566],{"id":1565},"требования-к-оформлению-отчёта","Требования к оформлению отчёта",[20,1568,1569],{},"Отчёт должен содержать:",[386,1571,1572,1575,1578,1581,1584],{},[336,1573,1574],{},"титульный лист с указанием номера лабораторной работы, темы, имени студента и номера группы;",[336,1576,1577],{},"краткое описание конфигурации рабочего места: характеристики хостовой машины, версия операционной системы, версия Docker Engine;",[336,1579,1580],{},"результаты каждой из четырёх частей задания: выполненные команды и их вывод, наблюдения, ответы на поставленные вопросы;",[336,1582,1583],{},"заполненную сравнительную таблицу из части 4;",[336,1585,1586],{},"общий вывод по работе (5–10 предложений): что было изучено, какие свойства контейнеризации проявились на практике, в чём контейнер оказался удобнее и в чём ограниченнее виртуальной машины.",[20,1588,1589],{},"Скриншоты прилагаются по необходимости для подтверждения выполненных шагов. Вывод команд допускается вставлять как текст в блоках кода.",[15,1591,1593],{"id":1592},"контрольные-вопросы","Контрольные вопросы",[333,1595,1596,1603,1610,1613,1616,1619,1622],{},[336,1597,1598,1599,1602],{},"Какие действия выполняет Docker при обработке команды ",[294,1600,1601],{},"docker run",", если указанный образ отсутствует локально?",[336,1604,1605,1606,1609],{},"Почему контейнер завершает работу сразу после выполнения команды ",[294,1607,1608],{},"echo","? Каким образом нужно запустить контейнер, чтобы он оставался активным?",[336,1611,1612],{},"Объясните различие между образом и контейнером. Можно ли изменить содержимое образа, записав файл внутри работающего контейнера?",[336,1614,1615],{},"Два контейнера созданы из одного образа. Изменение файла в первом контейнере не отражается во втором. Какой механизм это обеспечивает?",[336,1617,1618],{},"Перечислите пространства имён Linux, используемые при контейнеризации, и поясните роль каждого. Какое пространство имён отвечает за то, что контейнер видит собственный PID 1?",[336,1620,1621],{},"Чем ограничение ресурсов через cgroups отличается от изоляции через пространства имён? Приведите пример ситуации, когда отсутствие лимитов cgroups приводит к проблемам в многоконтейнерной среде.",[336,1623,1624],{},"Что произойдёт с данными, записанными в файловую систему контейнера, если контейнер будет удалён? Каким образом можно сохранить данные между пересозданиями контейнера?",[1626,1627,1628],"style",{},"html pre.shiki code .sScJk, html code.shiki .sScJk{--shiki-default:#6F42C1;--shiki-dark:#B392F0}html pre.shiki code .sZZnC, html code.shiki .sZZnC{--shiki-default:#032F62;--shiki-dark:#9ECBFF}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html pre.shiki code .sJ8bj, html code.shiki .sJ8bj{--shiki-default:#6A737D;--shiki-dark:#6A737D}html pre.shiki code .sj4cs, html code.shiki .sj4cs{--shiki-default:#005CC5;--shiki-dark:#79B8FF}html pre.shiki code .szBVR, html code.shiki .szBVR{--shiki-default:#D73A49;--shiki-dark:#F97583}",{"title":232,"searchDepth":233,"depth":233,"links":1630},[1631,1632,1633,1639,1640],{"id":272,"depth":233,"text":273},{"id":279,"depth":233,"text":280},{"id":317,"depth":233,"text":318,"children":1634},[1635,1636,1637,1638],{"id":324,"depth":239,"text":325},{"id":434,"depth":239,"text":435},{"id":750,"depth":239,"text":751},{"id":1106,"depth":239,"text":1107},{"id":1565,"depth":233,"text":1566},{"id":1592,"depth":233,"text":1593},{},"\u002Fcourses\u002Faidt-bac-cloud_tech\u002Ftopic-03-lr","lr",{"title":264,"description":232},"courses\u002Faidt-bac-cloud_tech\u002Ftopic-03-lr","Io4nUXnUZN4b9jMBcS9k4vZjNIc4marj2gLZvadtMBI",{"id":1648,"title":1649,"body":1650,"course_slug":250,"description":232,"env_label":251,"env_url":251,"extension":252,"group":1681,"is_course_project":253,"is_index":255,"level":1682,"meta":1683,"navigation":255,"path":1686,"section":251,"seo":1687,"stem":1688,"topic_number":251,"topic_slug":251,"__hash__":1689},"courses\u002Fcourses\u002Faidt-bac-cloud_tech\u002Findex.md","Облачные технологии",{"type":8,"value":1651,"toc":1679},[1652,1655],[11,1653,1649],{"id":1654},"облачные-технологии",[386,1656,1657,1665,1672],{},[336,1658,1659,1660],{},"Требования к материалам: ",[1661,1662,1664],"a",{"href":1663},".\u002Fshared\u002FSTYLEGUIDE","shared\u002FSTYLEGUIDE.md",[336,1666,1667,1668],{},"Содержание курса: ",[1661,1669,1671],{"href":1670},".\u002Ftopics","topics.md",[336,1673,1674,1675],{},"Инструкция по сдаче работ: ",[1661,1676,1678],{"href":1677},".\u002Fshared\u002Fsubmission","shared\u002Fsubmission.md",{"title":232,"searchDepth":233,"depth":233,"links":1680},[],"bachelor","бакалавриат",{"topics_count":1030,"has_lr":255,"has_pz":253,"has_course_project":255,"final_assessment":1684,"tech_focus":1685},"зачет","Облачные технологии, контейнеризация, Docker","\u002Fcourses\u002Faidt-bac-cloud_tech",{"title":1649,"description":232},"courses\u002Faidt-bac-cloud_tech\u002Findex","uo9ftIk0ye9G2gRrb5M7uFNZQgYvuCJ8j7yJSmoQuGo",1779455410875]