Contenedor WSL

La característica de contenedor WSL tiene dos componentes principales: una CLI denominada wslc.exe para compilar, ejecutar e interactuar con contenedores de Linux y una API de contenedor de WSL que permite a los desarrolladores de aplicaciones Windows usar contenedores de Linux como parte de su lógica de aplicación.

Importante

La característica de contenedor WSL requiere WSL versión 2.9.3 o posterior. Esta versión solo está disponible actualmente como versión preliminar, por lo que debe instalarla abriendo PowerShell y escribiendo:

wsl --update --pre-release

Compruebe la versión instalada en cualquier momento con wsl --version.

CLI del contenedor WSL

WSL ahora incluye wslc.exe como binario integrado. Su objetivo es tener una interfaz familiar de la CLI, lo que le permite compilar, ejecutar e interactuar fácilmente con contenedores de Linux.

Consulte algunos de los comandos de ejemplo siguientes:

# 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

Puede obtener más información sobre cómo empezar a trabajar con esta característica en nuestro tutorial de contenedor.

API de contenedor de WSL

Windows aplicaciones también pueden usar contenedores de Linux. El paquete NuGet de la API de contenedor de WSL permite extraer, ejecutar e interactuar mediante programación con contenedores de Linux, incluidas interacciones clave como stdin y stdout, montajes de archivos, montajes de red, acceso a GPU y mucho más.

Para ver la superficie completa de la API en las proyecciones de C, C# y C++, consulte la Referencia de la API del contenedor WSL.

Instalación de la API

La API del contenedor WSL se incluye en el Microsoft.WSL.Containerspaquete NuGet, que proporciona tanto la proyección de C# como los encabezados de C++/WinRT.

C#

Agregue el paquete al proyecto con la CLI de .NET:

dotnet add package Microsoft.WSL.Containers

A continuación, importe el espacio de nombres en el código:

using Microsoft.WSL.Containers;

C++

Añada el Microsoft.WSL.Containerspaquete NuGet a su proyecto de C++/WinRT, luego incluya el encabezado proyectado e incorpore el espacio de nombres al ámbito:

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

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

Nota:

La proyección de C++/WinRT está en versión preliminar y está sujeta a cambios importantes.

Introducción a la API

La API se organiza en torno a un pequeño conjunto de objetos que reflejan el ciclo de vida de ejecutar un contenedor:

Objeto	Descripción
WslcService	Punto de entrada estático para operaciones a nivel de servicio. Úselo para comprobar que los componentes de WSL necesarios están instalados, consulte la versión del servicio e instale las dependencias que faltan.
Session	Un host basado en WSL que ejecuta tus contenedores. Una sesión administra imágenes (extracción, importación, carga, inserción, etiqueta, eliminación) y crea contenedores.
Container	Un contenedor creado dentro de una sesión. Úselo para iniciar, detener, inspeccionar y eliminar el contenedor y ejecutar procesos adicionales dentro de él.
Process	Un proceso de Linux que se ejecuta en un contenedor. Úselo para leer stdout/stderr, escribir en stdin, enviar señales y consultar los códigos de salida mediante eventos.

Un flujo típico es: compruebe los requisitos previos con WslcService, cree e inicie un Session, extraiga una imagen, configure y cree un Container, después, inícielo e interactúe con sus Process objetos.

Fragmentos de código de ejemplo

Los fragmentos de código siguientes muestran los mismos bloques de creación principales en cada idioma admitido. Use las pestañas para cambiar entre C# y C++.

C#

Compruebe que los componentes necesarios están instalados:

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

Cree e inicie una sesión:

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

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

Descargar una imagen con información de progreso:

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;

Cree un contenedor, ejecute un comando y lea su salida:

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();

Cuando haya terminado, detenga y elimine el contenedor y, a continuación, finalice la sesión para liberar recursos:

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

C++

Estos fragmentos de código usan C++/WinRT. Las llamadas asincrónicas usan co_await, por lo que deben ejecutarse dentro de una corrutina.

Compruebe que los componentes necesarios están instalados:

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

Cree e inicie una sesión:

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

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

Descargar una imagen con información de progreso:

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;

Cree un contenedor, ejecute un comando y lea su salida:

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();

Cuando haya terminado, detenga y elimine el contenedor y, a continuación, finalice la sesión para liberar recursos:

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

Ejemplos completos de un extremo a otro

Los fragmentos de código anteriores muestran los componentes básicos. Para ver ejemplos completos y ejecutables que abarcan el ciclo de vida completo del contenedor, la administración de imágenes, las asignaciones de puertos, los montajes de volúmenes, el acceso a GPU y el streaming interactivo stdin/stdout , consulte los ejemplos de API de contenedor de WSL.