Windows контейнеры вручную. Часть 5: Запускаем контейнер без рантайма через HCS

Все части серии «Windows контейнеры вручную»

В четвёртой части мы скачали образ без containerd, разложили его слои утилитой wclayer и посмотрели, что containerd передаёт shim: слои и спецификацию OCI. Дальше shim превращает это в JSON-документ HCS и вызывает HCS. Сегодня сделаем работу shim сами: напишем небольшую программу, которая вызывает HCS и HNS напрямую, и запустим в контейнере тот же пример ASP.NET — с сетью, публикацией порта, подключённой папкой и лимитами. Ни containerd, ни shim, ни спецификации OCI в этой части не будет.

Код и скрипты — в папке 05-hcs репозитория.


HCS API

HCS (Host Compute Service, служба vmcompute) создаёт и контейнеры, и виртуальные машины. Программы обращаются к ней через библиотеку computecore.dll — ту самую, которую мы нашли в системе в первой части ещё до установки компонента Containers. В API три идеи:

  • Дескрипторы. Вычислительная система (compute system — так HCS называет и контейнер, и виртуальную машину) и процесс в ней представлены дескрипторами HCS_SYSTEM и HCS_PROCESS. Систему можно открыть по имени из другой программы.
  • Операции. Вызовы, которые что-то делают с системой или процессом, асинхронные: каждому передаётся операция HCS_OPERATION, а результат забирается ожиданием на ней — HcsWaitForOperationResult. Результат или описание ошибки приходят JSON-документом.
  • JSON-документы. Что создать и как, описывается документом по схеме HCS: для системы — её хранилище, сеть, лимиты; для процесса — командная строка, пользователь, окружение, каналы ввода-вывода.

Нам понадобятся одиннадцать функций, не считая закрытия дескрипторов:

Функция Что делает
HcsCreateOperation создаёт операцию для асинхронного вызова
HcsWaitForOperationResult ждёт операцию и отдаёт документ с результатом
HcsWaitForOperationResultAndProcessInfo то же для создания процесса, вместе с дескрипторами его каналов
HcsCreateComputeSystem создаёт систему по документу
HcsStartComputeSystem запускает её
HcsOpenComputeSystem открывает существующую систему по имени
HcsGetComputeSystemProperties свойства системы
HcsCreateProcess запускает в системе процесс
HcsGetProcessProperties состояние процесса и код возврата
HcsTerminateComputeSystem останавливает систему
HcsEnumerateComputeSystems список систем

Сеть — отдельная служба HNS со своей библиотекой computenetwork.dll и тем же подходом: дескрипторы и JSON. Что такое сеть, конечная точка и сетевой отсек HNS, разобрано в части 37 серии о Kubernetes.


hcsctl

Программа hcsctl — 435 строк на C#, собранных через Native AOT, как name-ipam во второй части. JSON-документы она не строит: их пишем мы, а она только передаёт их HCS. Объявление функций — LibraryImport, генератор кода для вызовов неуправляемых функций:

[LibraryImport("computecore.dll")]
private static partial IntPtr HcsCreateOperation(IntPtr context, IntPtr callback);

[LibraryImport("computecore.dll")]
private static partial int HcsWaitForOperationResult(IntPtr operation, uint timeoutMs, out IntPtr resultDocument);

[LibraryImport("computecore.dll", StringMarshalling = StringMarshalling.Utf16)]
private static partial int HcsCreateComputeSystem(string id, string configuration, IntPtr operation, IntPtr securityDescriptor, out IntPtr computeSystem);

[LibraryImport("computecore.dll", StringMarshalling = StringMarshalling.Utf16)]
private static partial int HcsStartComputeSystem(IntPtr computeSystem, IntPtr operation, string? options);

Каждый вызов проходит одинаково: вызвали функцию с операцией, дождались операции, забрали документ. Это вынесено в одну функцию:

static string Wait(IntPtr op, int hr, string what)
{
    if (hr < 0) throw new InvalidOperationException($"{what}: 0x{hr:X8}");
    hr = HcsWaitForOperationResult(op, Infinite, out var doc);
    var result = TakeString(doc);
    if (hr < 0) throw new InvalidOperationException($"{what}: 0x{hr:X8} {result}");
    return result;
}

TakeString превращает строку, выделенную HCS, в строку .NET и освобождает память через LocalFree. Создание системы — два вызова на одной операции:

public static void Create(string id, string document)
{
    var op = HcsCreateOperation(IntPtr.Zero, IntPtr.Zero);
    try
    {
        Wait(op, HcsCreateComputeSystem(id, document, op, IntPtr.Zero, out var system), "HcsCreateComputeSystem");
        try
        {
            Wait(op, HcsStartComputeSystem(system, op, null), "HcsStartComputeSystem");
        }
        finally
        {
            HcsCloseComputeSystem(system);
        }
    }
    finally
    {
        HcsCloseOperation(op);
    }
}

Команды hcsctl повторяют привычные по Docker:

Команда Что делает
create <id> <system.json> создаёт и запускает систему по документу
exec [-d] <id> <process.json> запускает процесс; без -d печатает его вывод и возвращает код возврата
ls, props <id> список систем и свойства одной
rm <id> останавливает систему
net <namespace> <network> <ip>/<prefix> <gateway> <dns> [host:container ...] создаёт конечную точку HNS и сетевое пространство имён
net-rm <namespace> удаляет их
layer-id <folder> GUID слоя для документа

Собираем на рабочей машине. Напомним, что, кроме .NET SDK 10, Native AOT нужен компоновщик из Visual Studio или Build Tools с компонентом C++, а ищет его сборка утилитой vswhere.exe, которой может не оказаться в PATH. Поэтому первая строка добавляет туда каталог установщика Visual Studio:

$env:Path += ";${env:ProgramFiles(x86)}\Microsoft Visual Studio\Installer"
dotnet publish -c Release -o out
Get-ChildItem out | Format-Table Name, Length
Name        Length
----        ------
hcsctl.exe 1743360
hcsctl.pdb 9105408

На сервер нужен только hcsctl.exe: кладём его в C:\hcs, рядом с wclayer.exe. Туда же скачаем скрипты, которые понадобятся ниже:

foreach ($f in 'run-container.ps1', 'remove-container.ps1', 'cpu-test.ps1') {
    curl.exe -sSLo "C:\hcs\$f" "https://raw.githubusercontent.com/vitaliy-leschenko/windows-containers-by-hand/main/05-hcs/$f"
}

Первый контейнер

Для опытов нужны два образа: Nano Server и пример ASP.NET от Microsoft. Скачаем их скриптом pull-image.ps1, который лежит в C:\hcs, а рядом запустим контейнер web с тем же примером под управлением containerd, чтобы сравнивать с ним наши контейнеры:

pull-image.ps1 mcr.microsoft.com/windows/nanoserver:ltsc2025 C:\images\nanoserver
pull-image.ps1 mcr.microsoft.com/dotnet/samples:aspnetapp-nanoserver-ltsc2025 C:\images\samples
nerdctl run -d --name web -p 8080:8080 mcr.microsoft.com/dotnet/samples:aspnetapp-nanoserver-ltsc2025

Начнём с самого простого: Nano Server без сети. Диск контейнера готовим, как в четвёртой части: записываемый слой поверх слоя образа, подключённый как том. Папку-цель wclayer mount на этот раз не даём — нужен путь тома:

New-Item -ItemType Directory C:\lab\hcs -Force | Out-Null; Set-Location C:\lab\hcs
$base = 'C:\images\nanoserver\layers\9a4c0752c6bda5fc00f886a9acf0c0afed0750082f7999c331df978fb9f97d2a'
wclayer create -l $base C:\layers\hello
$volume = wclayer mount -l $base C:\layers\hello
$lid = hcsctl layer-id $base
$volume
$lid
\\?\Volume{1896b46a-29d4-403c-92d3-a2080cb86690}
13962ae5-0ef1-5a3b-881c-5e9fa8000f5e

В документе HCS у каждого слоя есть путь и GUID. GUID получается из имени папки слоя функцией NameToGuid из vmcompute.dll — так же его считает hcsshim, — это и делает hcsctl layer-id. Документ системы — hello.json:

{
    "SchemaVersion": { "Major": 2, "Minor": 1 },
    "Owner": "hcsctl",
    "ShouldTerminateOnLastHandleClosed": false,
    "Container": {
        "GuestOs": { "HostName": "hello" },
        "Storage": {
            "Layers": [
                {
                    "Id": "13962ae5-0ef1-5a3b-881c-5e9fa8000f5e",
                    "Path": "C:\\images\\nanoserver\\layers\\9a4c0752c6bda5fc00f886a9acf0c0afed0750082f7999c331df978fb9f97d2a"
                }
            ],
            "Path": "\\\\?\\Volume{1896b46a-29d4-403c-92d3-a2080cb86690}"
        }
    }
}
  • SchemaVersion — версия схемы документов HCS.
  • Owner — владелец, его показывает hcsdiag list.
  • ShouldTerminateOnLastHandleClosed: false — система переживает закрытие дескриптора, то есть выход hcsctl. Иначе контейнер жил бы, только пока работает программа, которая его создала.
  • Container — это контейнер, а не виртуальная машина. Он работает на ядре хоста, с изоляцией процессов: hcsctl props ниже покажет "IsolationType": "Process".
  • GuestOs.HostName — имя компьютера внутри контейнера. Это поле нужно задавать всегда, ниже разберём почему.
  • Storage.Layers — слои образа сверху вниз, Storage.Path — том записываемого слоя: его HCS сделает диском C: контейнера.
hcsctl create hello hello.json
hcsdiag list
hello
e3f3aa09b67d4555b7619e202e25dca92bc8cd636045dfb1a2849a729052da73
    Windows Server Container, 	Running,                                     , containerd-shim-runhcs-v1.exe, 2

hello
    Windows Server Container, 	Running,                                     , hcsctl, 4

Рядом с контейнером web, которым управляет shim containerd, появился наш hello — тоже Windows Server Container, владелец hcsctl, сеанс 4.

Процессы

Система работает, но своего процесса в ней пока нет — его запускают отдельно. Процесс описывается своим документом — ver.json:

{
    "CommandLine": "cmd /c ver & hostname & echo %USERNAME% & dir /b C:\\",
    "WorkingDirectory": "C:\\",
    "CreateStdOutPipe": true,
    "CreateStdErrPipe": true
}
hcsctl exec hello ver.json

Microsoft Windows [Version 10.0.26100.33674]
hello
ContainerAdministrator
License.txt
Users
Windows

Имя из GuestOs.HostName, корень диска — файлы слоя Nano Server. Пользователь — ContainerAdministrator, хотя у образа Nano Server в конфигурации записан ContainerUser. HCS ничего не знает об образах: конфигурацию образа читает containerd, а HCS по умолчанию запускает процесс от администратора контейнера. Пользователя, окружение и код возврата задаём сами — user.json:

{
    "CommandLine": "cmd /c echo %USERNAME%: %GREETING% & exit 3",
    "User": "ContainerUser",
    "Environment": { "GREETING": "hello from hcsctl" },
    "CreateStdOutPipe": true,
    "CreateStdErrPipe": true
}
hcsctl exec hello user.json
"exit code: $LASTEXITCODE"
ContainerUser: hello from hcsctl
exit code: 3

CreateStdOutPipe и CreateStdErrPipe просят HCS создать каналы для вывода процесса. Их дескрипторы вместе с номером процесса приходят из HcsWaitForOperationResultAndProcessInfo — ожидания операции HcsCreateProcess, — и hcsctl копирует из них в свой вывод, пока процесс их не закроет. Потом спрашивает HcsGetProcessProperties, пока не получит "Exited": true с кодом возврата:

var hr = HcsCreateProcess(system, parameters, op, IntPtr.Zero, out var process);
if (hr < 0) throw new InvalidOperationException($"HcsCreateProcess: 0x{hr:X8}");
hr = HcsWaitForOperationResultAndProcessInfo(op, Infinite, out var info, out var doc);
// ...
var copies = new[]
{
    Wants("CreateStdOutPipe") ? Copy(info.StdOutput, Console.OpenStandardOutput()) : Task.CompletedTask,
    Wants("CreateStdErrPipe") ? Copy(info.StdError, Console.OpenStandardError()) : Task.CompletedTask,
};
Task.WaitAll(copies);
return ExitCode(process);

Каналы, которые в документе не запрошены, не создаются, и их дескрипторы недействительны: первая версия hcsctl пыталась читать из такого дескриптора и падала с «Invalid handle». Это и есть то, что не получилось у runhcs в четвёртой части: вывод контейнера доходит до терминала.

Имя контейнера

Имя, которое мы передали в hcsctl create, — идентификатор системы для HCS. Внутрь контейнера он не попадает: имя компьютера задаёт только GuestOs.HostName, и, когда запускаем контейнер сами, это поле обязательно. Запустим такой же контейнер с разными значениями поля и процессом cmd /c hostname & echo %COMPUTERNAME%:

GuestOs.HostName hostname %COMPUTERNAME%
не задано minwinpc MINWINPC
Web-Two Web-Two WEB-TWO
abcdefghij12345 abcdefghij12345 ABCDEFGHIJ12345
a-long-container-name2 a-long-container-name2 A-LONG-CONTAINE

Без поля все контейнеры называются одинаково — minwinpc, и приложения, которые пишут имя компьютера в журналы или регистрируются под ним, не отличат один контейнер от другого. Одно поле задаёт сразу оба имени: hostname — как записано, а COMPUTERNAME — в верхнем регистре и не длиннее 15 символов, это ограничение имён NetBIOS. Если длинное имя нужно приложению целиком, переменную задают в документе процесса:

{
    "CommandLine": "cmd /c hostname & echo %COMPUTERNAME%",
    "Environment": { "COMPUTERNAME": "a-long-container-name2" },
    "CreateStdOutPipe": true,
    "CreateStdErrPipe": true
}
a-long-container-name2
a-long-container-name2

Скрипт run-container.ps1 в конце этой части делает то же: записывает имя контейнера в GuestOs.HostName, а для имён длиннее 15 символов ещё и в COMPUTERNAME.

Что HCS знает о системе

hcsctl props hello
{
    "Id": "hello",
    "SystemType": "Container",
    "RuntimeOsType": "Windows",
    "Owner": "hcsctl",
    "ObRoot": "\\\\.\\Silos\\980",
    "State": "Running",
    "ServiceSessionId": 4,
    "IsolationType": "Process"
}

ObRoot — корень пространства объектов контейнера, тот самый каталог \Silos\<номер>, который мы разбирали в третьей части. ServiceSessionId — сеанс, в котором работают процессы контейнера. Останавливаем систему и отключаем записываемый слой:

hcsctl rm hello
wclayer unmount C:\layers\hello

Сеть

У hello нет сетевого адаптера: в документе не было раздела Networking. Сеть контейнера в HNS — это конечная точка (endpoint) в сети HNS, помещённая в сетевое пространство имён (namespace); пространство и указывается в документе контейнера. Сеть возьмём готовую — nat, которую CNI-плагин создал при запуске контейнера web, — а конечную точку и пространство создадим сами через computenetwork.dll.

Конечная точка описывается JSON, который hcsctl net собирает из аргументов:

{
    "SchemaVersion": { "Major": 2, "Minor": 0 },
    "Owner": "hcsctl",
    "HostComputeNetwork": "<GUID сети nat>",
    "IpConfigurations": [ { "IpAddress": "172.30.0.50", "PrefixLength": 16 } ],
    "Routes": [ { "NextHop": "172.30.0.1", "DestinationPrefix": "0.0.0.0/0" } ],
    "Dns": { "ServerList": [ "172.30.0.1" ] },
    "Policies": [
        { "Type": "PortMapping", "Settings": { "Protocol": 6, "ExternalPort": 8081, "InternalPort": 8080 } }
    ]
}

Адрес задаём сами — тот, что во второй части выдал бы IPAM-плагин. Маршрут по умолчанию — через шлюз сети, DNS-сервер — CoreDNS на том же шлюзе. PortMapping — та же политика NAT, которую в первой части повесил на конечную точку плагин nat для -p 8080:8080; протокол 6 — TCP. Дальше — пространство имён и конечная точка в нём:

hr = HcnCreateNamespace(nsId, $$"""{"SchemaVersion": {{Schema}}, "Type": "Host"}""", out var ns, out error);
Check(hr, error, "HcnCreateNamespace");
hr = HcnModifyNamespace(ns, $$$"""{"ResourceType": "Endpoint", "RequestType": "Add", "Settings": {"EndpointId": "{{{endpointId}}}"}}""", out error);
Check(hr, error, "HcnModifyNamespace");

Тип пространства важен. Сначала я написал HostDefault, и контейнер не создавался с ошибкой 0x80070490 (Element not found). HostDefault — пространство имён хоста по умолчанию, оно одно, и HNS не создаёт новое, а отдаёт существующее, не глядя на переданный GUID. Конечная точка уехала в него, а пространства с нашим GUID так и не появилось. Нужен тип Host — отдельное пространство:

$ns = [guid]::NewGuid()
$ns
hcsctl net $ns nat 172.30.0.50/16 172.30.0.1 172.30.0.1 8081:8080
hnsdiag list namespaces | Select-String -Context 0,1 $ns
ba4ccad4-b088-4197-8445-f73e2c10c8ba
endpoint b4949713-4c59-4304-90cb-9b1f10808b33
address  172.30.0.50
mac      00-15-5D-43-E1-4C
ports    8081:8080
> Namespace        : ba4ccad4-b088-4197-8445-f73e2c10c8ba
      Endpoint IDs     : B4949713-4C59-4304-90CB-9B1F10808B33

Пример ASP.NET

Теперь соберём контейнер для примера ASP.NET из образа C:\images\samples: тринадцать слоёв, сеть, подключённая папка, лимиты. Записываемый слой — поверх всех слоёв из layers.json:

$layers = Get-Content C:\images\samples\layers.json | ConvertFrom-Json
$l = foreach ($p in $layers) { '-l'; $p }
wclayer create @l C:\layers\web2
$volume = wclayer mount @l C:\layers\web2
$volume
\\?\Volume{929f72e1-7355-4b29-9bbf-9b35d34095b0}

Тринадцать слоёв руками в JSON вписывать незачем — соберём документ в PowerShell:

New-Item -ItemType Directory C:\share -Force | Out-Null
'hello from host' | Set-Content C:\share\hello.txt
[ordered]@{
    SchemaVersion = [ordered]@{ Major = 2; Minor = 1 }
    Owner = 'hcsctl'
    ShouldTerminateOnLastHandleClosed = $false
    Container = [ordered]@{
        GuestOs = @{ HostName = 'web2' }
        Storage = [ordered]@{
            Layers = @(foreach ($p in $layers) { [ordered]@{ Id = (hcsctl layer-id $p); Path = $p } })
            Path = $volume
        }
        MappedDirectories = @([ordered]@{ HostPath = 'C:\share'; ContainerPath = 'C:\data'; ReadOnly = $true })
        Memory = @{ SizeInMB = 512 }
        Processor = @{ Count = 1 }
        Networking = [ordered]@{ AllowUnqualifiedDnsQuery = $true; Namespace = "$ns" }
    }
} | ConvertTo-Json -Depth 6 | Set-Content web2.json -Encoding ascii
hcsctl create web2 web2.json

Новые разделы — то, что в первой части делали ключи nerdctl:

  • MappedDirectories — подключённые папки хоста, -v C:\share:C:\data:ro. Их встраивает фильтр bindflt из третьей части.
  • Memory.SizeInMB и Processor.Count — --memory 512m и --cpus 1.
  • Networking.Namespace — пространство имён с нашей конечной точкой, а AllowUnqualifiedDnsQuery разрешает запросы коротких имён без суффикса — то же поле containerd ставил в спецификации OCI.

Проверим, что внутри, процессом из inside.json:

{
    "CommandLine": "cmd /c hostname & ipconfig | findstr IPv4 & type C:\\data\\hello.txt & echo x> C:\\data\\x.txt",
    "CreateStdOutPipe": true,
    "CreateStdErrPipe": true
}
hcsctl exec web2 inside.json
web2
   IPv4 Address. . . . . . . . . . . : 172.30.0.50
hello from host
Access is denied.

Имя, адрес, подключённая папка, запрет записи — всё на месте. Осталось запустить само приложение. Что запускать, знает конфигурация образа — image.json, который сохранил pull-image.ps1. Переложим её в документ процесса:

$config = (Get-Content C:\images\samples\image.json | ConvertFrom-Json).config
$environment = [ordered]@{}
foreach ($e in $config.Env) { $k, $v = $e -split '=', 2; $environment[$k] = $v }
[ordered]@{
    CommandLine = $config.Entrypoint -join ' '
    WorkingDirectory = $config.WorkingDir
    User = $config.User
    Environment = $environment
} | ConvertTo-Json | Set-Content app.json -Encoding ascii
Get-Content app.json
hcsctl exec -d web2 app.json
{
    "CommandLine": "AspNetCoreRazorApp",
    "WorkingDirectory": "C:\\app",
    "User": "ContainerUser",
    "Environment": {
        "ASPNETCORE_HTTP_PORTS": "8080",
        "DOTNET_RUNNING_IN_CONTAINER": "true",
        "DOTNET_VERSION": "11.0.0-rc.3.26522.148",
        "ASPNET_VERSION": "11.0.0-rc.3.26522.148"
    }
}
process 4952

Это та часть работы containerd, которую в четвёртой части мы видели в спецификации OCI: Entrypoint — в командную строку, Env — в окружение, WorkingDir и User — как есть. С -d hcsctl не ждёт процесс и выходит, а процесс продолжает работать. Проверим с хоста, из контейнера web, которым управляет containerd, и с другой машины в сети:

curl.exe -sS -o NUL -w "%{http_code}`n" http://localhost:8081/
nerdctl exec web curl.exe -sS -o NUL -w "%{http_code}`n" http://172.30.0.50:8080/
200
200
curl.exe -sS -o NUL -w "%{http_code}`n" http://192.168.10.30:8081/
200

Порт 8081 хоста ведёт в наш контейнер, а контейнеры containerd и наш живут в одной сети nat и видят друг друга по адресам.

Как это выглядит с хоста

hcsdiag list
Get-Process AspNetCoreRazorApp | Format-Table Name, Id, SessionId
e3f3aa09b67d4555b7619e202e25dca92bc8cd636045dfb1a2849a729052da73
    Windows Server Container, 	Running,                                     , containerd-shim-runhcs-v1.exe, 2

web2
    Windows Server Container, 	Running,                                     , hcsctl, 4

Name                 Id SessionId
----                 -- ---------
AspNetCoreRazorApp 4952         4
AspNetCoreRazorApp 6572         2

Два одинаковых приложения в двух контейнерах: одно в сеансе 2 (контейнер containerd), другое — в сеансе 4, наше. Лимит памяти найдём в объекте задания, как в третьей части:

Import-Module NtObjectManager
$session = (hcsctl props web2 | ConvertFrom-Json).ServiceSessionId
$p = Get-Process AspNetCoreRazorApp | Where-Object SessionId -eq $session
$job = Get-NtProcessJob -Process (Get-NtProcess -ProcessId $p.Id)
$job | Format-List Name, LimitFlags, JobMemory
$job.Close()
Name       : Container_web2
LimitFlags : JobMemory
JobMemory  : 536870912

Объект задания называется Container_ плюс имя системы, лимит — 512 МиБ, ровно SizeInMB. $job.Close() здесь не для красоты. Открытый дескриптор держит объект задания живым и после остановки контейнера, и пока он открыт, контейнер с тем же именем не создаётся: HcsCreateComputeSystem отвечает 0x800700B7 — «уже существует». На этом я споткнулся, когда пересоздавал web2 в той же сессии PowerShell.

Лимит процессора проверим так же, как в первой части: нагрузим контейнер и посчитаем процессорное время его процессов. Скрипт cpu-test.ps1 создаёт контейнер Nano Server через hcsctl, с Processor.Count или без, запускает в нём четыре бесконечных цикла cmd и складывает их процессорное время за 10 секунд:

cpu-test.ps1
cpu-test.ps1 -Cpus 1
no limit; session 5; CPU used: 3,98 of 4 cores
Processor.Count 1; session 5; CPU used: 0,99 of 4 cores

Разборка

Всё, что мы создали, убираем в обратном порядке: систему, пространство имён с конечной точкой, записываемый слой:

hcsctl rm web2
hcsctl net-rm $ns
wclayer unmount C:\layers\web2
hcsdiag list
@(Get-HnsEndpoint | Where-Object IPAddress -eq 172.30.0.50).Count
e3f3aa09b67d4555b7619e202e25dca92bc8cd636045dfb1a2849a729052da73
    Windows Server Container, 	Running,                                     , containerd-shim-runhcs-v1.exe, 2

0

wclayer unmount после остановки системы иногда пишет «hcsshim::UnprepareLayer failed in Win32: The device is not ready» — то же сообщение, что встречалось в четвёртой части. Том при этом отключается; на стенде это повторялось не каждый раз, и закономерности я не нашёл.


Всё одним скриптом

Шаги этой части собраны в run-container.ps1 и remove-container.ps1 — маленький рантайм поверх wclayer и hcsctl. Первый готовит хранилище, сеть, документ системы и процесс из конфигурации образа, второй всё это убирает. Что создано, записывается в C:\containers\<имя>:

run-container.ps1 web2 C:\images\samples -Ip 172.30.0.50 -Publish 8081:8080 -Mount C:\share:C:\data:ro -Memory 512 -Cpus 1
curl.exe -sS -o NUL -w "%{http_code}`n" http://localhost:8081/
Get-ChildItem C:\containers\web2 | Format-Table Name, Length
remove-container.ps1 web2
Test-Path C:\containers\web2
volume \\?\Volume{4b8064d0-52fc-43a5-bb2b-aa514fddb9e2}
endpoint 172.30.0.50 in nat, namespace fd2694b0-f7d0-48aa-9cb3-c0af54c717b6
compute system web2
process 3216
200

Name         Length
----         ------
scratch
process.json 424
state.json   136
system.json  6563

False

Около ста строк PowerShell и программа на C# делают то, ради чего мы в первой части ставили containerd, nerdctl и CNI-плагин.


Убираем за собой

Контейнер web, образы, записываемые слои и рабочие папки этой части больше не понадобятся. Папки слоёв удаляет wclayer remove, остальное — обычный Remove-Item:

Set-Location C:\
nerdctl rm -f web
nerdctl rmi mcr.microsoft.com/dotnet/samples:aspnetapp-nanoserver-ltsc2025
foreach ($d in 'C:\layers\hello', 'C:\layers\web2') { wclayer remove $d }
Get-ChildItem C:\images\*\layers -Directory | ForEach-Object { wclayer remove $_.FullName }
Remove-Item C:\images, C:\layers, C:\share, C:\lab, C:\containers -Recurse -Force

wclayer, hcsctl и скрипты в C:\hcs остаются на сервере.


Чего не хватает до настоящего рантайма

Контейнер работает, но containerd и его shim делают больше:

  • Следят за процессами. Shim подписывается на события HCS и узнаёт, что процесс завершился, сразу, а не опросом. containerd хранит код возврата, nerdctl перезапускает контейнер по политике и ведёт журнал вывода — то, что показывает nerdctl logs.
  • Ввод и терминал. CreateStdInPipe и EmulateConsole в документе процесса дают интерактивный exec -it; hcsctl их не использует.
  • Убирают за собой. Если упадёт hcsctl или перезагрузится хост, система HCS, конечная точка и подключённый том останутся. containerd помнит, что создавал, и чистит это при следующем запуске.
  • Изоляция Hyper-V. Контейнер работает внутри служебной виртуальной машины со своим ядром. Это — следующая часть.

Итог

  • HCS API — дескрипторы, асинхронные операции и JSON-документы. Одиннадцати функций computecore.dll хватает, чтобы создать контейнер, запустить в нём процесс с выводом и остановить его.
  • Документ контейнера с изоляцией процессов — слои с GUID из NameToGuid, том записываемого слоя, подключённые папки, лимиты памяти и процессора и сетевое пространство имён.
  • Сеть — конечная точка HNS с адресом, маршрутом, DNS и политикой публикации порта, помещённая в пространство имён типа Host (не HostDefault).
  • Пользователь, окружение и команда — дело того, кто запускает процесс: HCS об образах не знает и по умолчанию запускает процесс от ContainerAdministrator.
  • Открытый дескриптор объекта задания не даёт создать контейнер с тем же именем.

Источники


Дальше — изоляция Hyper-V: тот же контейнер, но внутри служебной виртуальной машины. Что меняется в документе HCS, откуда берётся ядро для этой машины и что видно с хоста, когда контейнер работает не на его ядре.

Оставить комментарий могут только зарегистрированные пользователи.

Войдите на сайт или зарегистрируйтесь, чтобы оставить комментарий.