WSL-container

WSL-containerfunktionen har två huvudkomponenter: ett CLI som kallas wslc.exe för att skapa, köra och interagera med Linux-containrar och ett WSL-container-API som gör det möjligt för Windows apputvecklare att använda Linux-containrar som en del av sin applogik.

Important

WSL-containerfunktionen kräver WSL version 2.9.3 eller senare. Den här versionen är för närvarande endast tillgänglig som en förhandsversion, så du måste installera den genom att öppna PowerShell och ange:

wsl --update --pre-release

Kontrollera den installerade versionen när som helst med wsl --version.

CLI för WSL-container

WSL innehåller wslc.exe nu som en inbyggd binär fil. Målet är att ha ett välbekant CLI-gränssnitt så att du enkelt kan skapa, köra och interagera med Linux-containrar.

Se några av exempelkommandona nedan:

# Run a container
wslc run --rm -it ubuntu:latest bash -c "echo Hello world from WSL container!"
# List available images
wslc image ls
# Run a web server
wslc run -it --rm -d -p 8080:80 --name web nginx
# Get its content
curl localhost:8080
# List the container
wslc container ps
# Stop the container
wslc container stop web

Du kan läsa mer om hur du kommer igång med den här funktionen i vår självstudie om containrar.

WSL-container-API

Windows program kan också använda Linux-containrar! Med NuGet-paketet för WSL-container-API:t kan du programmatiskt hämta, köra och arbeta med Linux-containrar, inklusive viktiga funktioner som stdin och stdout, filmonteringar, nätverksanslutningar, GPU-åtkomst med mera.

Den fullständiga API-ytan i C-, C#- och C++-projektionerna finns i API-referensen för WSL-container.

Installera API:et

WSL-container-API:et Microsoft.WSL.Containers levereras i NuGet-paketet, som innehåller både C#-projektionen och C++/WinRT-huvudena.

C#

Lägg till paketet i projektet med .NET CLI:

dotnet add package Microsoft.WSL.Containers

Importera sedan namnområdet i koden:

using Microsoft.WSL.Containers;

C++

Lägg till NuGet-paketet Microsoft.WSL.Containers i ditt C++/WinRT-projekt och inkludera sedan den projicerade headerfilen och gör namnområdet tillgängligt i omfånget:

#include <winrt/Microsoft.WSL.Containers.h>

using namespace winrt::Microsoft::WSL::Containers;

Note

C++/WinRT-projektionen är i förhandsversion och kan komma att ändras.

API-översikt

API:et är organiserat kring en liten uppsättning objekt som speglar livscykeln för att köra en container:

Object	Description
WslcService	Statisk startpunkt för åtgärder på servicenivå. Använd den för att kontrollera att nödvändiga WSL-komponenter är installerade, fråga efter tjänstversionen och installera saknade beroenden.
Session	En WSL-baserad värd som kör dina containrar. En session hanterar avbildningar (pull, import, load, push, tag, delete) och skapar containrar.
Container	En container som skapats i en session. Använd den för att starta, stoppa, inspektera och ta bort containern och för att köra ytterligare processer i den.
Process	En Linux-process som körs i en container. Använd den för att läsa stdout/stderr, skriva till stdin, skicka signaler och observera utgångskoder via händelser.

Ett vanligt flöde är: verifiera kraven med WslcService, skapa och starta en Session, hämta en avbildning, konfigurera och skapa en Container, starta den och interagera med dess Process objekt.

Exempelkodavsnitt

Kodfragmenten nedan visar samma grundläggande byggstenar på varje språk som stöds. Använd flikarna för att växla mellan C# och C++.

C#

Kontrollera att nödvändiga komponenter är installerade:

ComponentFlags missing = WslcService.GetMissingComponents();
if (missing != ComponentFlags.None)
{
    Console.WriteLine($"WSL components are missing ({missing}). Run: wsl --install");
    return;
}

Skapa och starta en session:

var sessionSettings = new SessionSettings("MyApp", @"C:\WslcData")
{
    CpuCount = 4,
    MemoryMB = 4096
};

var session = new Session(sessionSettings);
session.Start();

Hämta en avbildning med förloppsrapportering:

var pull = session.PullImageAsync(new PullImageOptions("docker.io/library/alpine:latest"));
pull.Progress = (op, progress) =>
    Console.WriteLine($"Pull: {progress.Status} {progress.CurrentBytes}/{progress.TotalBytes}");
await pull;

Skapa en container, kör ett kommando och läs dess utdata:

var initProcess = new ProcessSettings
{
    CmdLine = new[] { "/bin/echo", "Hello from WSL Container!" },
    OutputMode = ProcessOutputMode.Event
};

var containerSettings = new ContainerSettings("alpine:latest")
{
    Name = "hello-container",
    InitProcess = initProcess
};

var container = session.CreateContainer(containerSettings);

container.InitProcess.OutputReceived += data =>
    Console.Write(Encoding.UTF8.GetString(data));

container.Start();

När du är klar stoppar och tar du bort containern och avslutar sedan sessionen för att frigöra resurser:

container.Stop(Signal.SIGTERM, TimeSpan.FromSeconds(10));
container.Delete(DeleteContainerFlags.None);
session.Terminate();

C++

Dessa kodfragment använder C++/WinRT. De asynkrona anropen använder co_await, så de måste köras i en coroutine.

Kontrollera att nödvändiga komponenter är installerade:

auto missing = WslcService::GetMissingComponents();
if (missing != ComponentFlags::None)
{
    printf("WSL components are missing. Run: wsl --install\n");
    return;
}

Skapa och starta en session:

SessionSettings sessionSettings{ L"MyApp", L"C:\\WslcData" };
sessionSettings.CpuCount(4);
sessionSettings.MemoryMB(4096);

Session session{ sessionSettings };
session.Start();

Hämta en avbildning med förloppsrapportering:

PullImageOptions pullOptions{ L"docker.io/library/alpine:latest" };
auto pull = session.PullImageAsync(pullOptions);
pull.Progress([](auto&&, ImageProgress const& progress)
{
    printf("Pull: %d %llu/%llu\n",
        static_cast<int>(progress.Status()),
        progress.CurrentBytes(),
        progress.TotalBytes());
});
co_await pull;

Skapa en container, kör ett kommando och läs dess utdata:

using namespace winrt::Windows::Foundation::Collections;

ProcessSettings initProcess;
initProcess.OutputMode(ProcessOutputMode::Event);

auto cmdLine = single_threaded_vector<hstring>();
cmdLine.Append(L"/bin/echo");
cmdLine.Append(L"Hello from WSL Container!");
initProcess.CmdLine(cmdLine);

ContainerSettings containerSettings{ L"alpine:latest" };
containerSettings.Name(L"hello-container");
containerSettings.InitProcess(initProcess);

auto container = session.CreateContainer(containerSettings);

container.InitProcess().OutputReceived([](auto const& data)
{
    std::string text(data.begin(), data.end());
    printf("%s", text.c_str());
});

container.Start();

När du är klar stoppar och tar du bort containern och avslutar sedan sessionen för att frigöra resurser:

container.Stop(Signal::SIGTERM, std::chrono::seconds(10));
container.Delete(DeleteContainerFlags::None);
session.Terminate();

Fullständiga exempel från slutpunkt till slutpunkt

Kodfragmenten ovan visar kärnbyggnadsblocken. Fullständiga, körbara exempel som täcker hela containerns livscykel, avbildningshantering, portmappningar, volymmonteringar, GPU-åtkomst och interaktiv stdin/stdout direktuppspelning finns i WSL-container-API-exemplen.