Azure Container Instances-Bibliotheken für .NETAzure Container Instances libraries for .NET

Verwenden Sie die Azure Container Instances-Bibliotheken für .NET zum Erstellen und Verwalten von Azure-Containerinstanzen.Use the Microsoft Azure Container Instances libraries for .NET to create and manage Azure container instances. In der Übersicht über Azure Container Instances erfahren Sie mehr.Learn more by reading the Azure Container Instances overview.

VerwaltungsbibliothekManagement library

Verwenden Sie die Verwaltungsbibliothek zum Erstellen und Verwalten von Azure-Containerinstanzen in Azure.Use the management library to create and manage Azure container instances in Azure.

Installieren Sie das NuGet-Paket direkt über die Paket-Manager-Konsole in Visual Studio oder mit der .NET Core CLI.Install the NuGet package directly from the Visual Studio Package Manager console or with the .NET Core CLI.

Visual Studio-Paket-ManagerVisual Studio Package Manager

Install-Package Microsoft.Azure.Management.ContainerInstance.Fluent
dotnet add package Microsoft.Azure.Management.ContainerInstance.Fluent

BeispielquelleExample source

Wenn Sie die folgenden Codebeispiele im Kontext sehen möchten, finden Sie sie im folgenden GitHub-Repository:If you'd like to see the following code examples in context, you can find them in the following GitHub repository:

Azure-Samples/aci-docs-sample-dotnetAzure-Samples/aci-docs-sample-dotnet

AuthentifizierungAuthentication

Eine der einfachsten Möglichkeiten zum Authentifizieren von SDK-Clients ist die Verwendung der dateibasierten Authentifizierung.One of the easiest ways to authenticate SDK clients is with file-based authentication. Bei der dateibasierten Authentifizierung wird beim Instanziieren des Clientobjekts IAzure eine Anmeldeinformationendatei analysiert. Diese Anmeldeinformationen werden anschließend für die Authentifizierung über Azure verwendet.File-based authentication parses a credentials file when instantiating the IAzure client object, which then uses those credentials when authenticating with Azure. So verwenden Sie die dateibasierte AuthentifizierungTo use file-based authentication:

  1. Erstellen Sie mit der Azure CLI oder mit Cloud Shell eine Datei mit Anmeldeinformationen:Create a credentials file with the Azure CLI or Cloud Shell:

    az ad sp create-for-rbac --sdk-auth > my.azureauth

    Wenn Sie Cloud Shell zum Erstellen der Datei mit Anmeldeinformationen verwenden, kopieren Sie ihren Inhalt in eine lokale Datei, auf die die .NET-Anwendung zugreifen kann.If you use the Cloud Shell to generate the credentials file, copy its contents into a local file that your .NET application can access.

  2. Legen Sie die Umgebungsvariable AZURE_AUTH_LOCATION auf den vollständigen Pfad der erstellten Datei mit Anmeldeinformationen fest.Set the AZURE_AUTH_LOCATION environment variable to the full path of the generated credentials file. Beispiel (in der Bash-Shell):For example (in the Bash shell):

    export AZURE_AUTH_LOCATION=/home/yourusername/my.azureauth
    

Nachdem Sie die Anmeldeinformationendatei erstellt und die Umgebungsvariable AZURE_AUTH_LOCATION aufgefüllt haben, initialisieren Sie das Clientobjekt IAzure mithilfe der Methode Azure.Authenticate.Once you've created the credentials file and populated the AZURE_AUTH_LOCATION environment variable, use the Azure.Authenticate method to initialize the IAzure client object. Das Beispielprojekt ruft zuerst den Wert AZURE_AUTH_LOCATION ab und ruft dann eine Methode auf, die ein initialisiertes IAzure-Clientobjekt zurückgibt:The example project first obtains the AZURE_AUTH_LOCATION value, then calls a method that returns an initialized IAzure client object:

// Set the AZURE_AUTH_LOCATION environment variable with the full
// path to an auth file. Create an auth file with the Azure CLI:
// az ad sp create-for-rbac --sdk-auth > my.azureauth
string authFilePath = Environment.GetEnvironmentVariable("AZURE_AUTH_LOCATION");

// Authenticate with Azure
IAzure azure = GetAzureContext(authFilePath);

Diese Methode aus der Beispielanwendung gibt die initialisierte IAzure-Instanz zurück, die dann als erster Parameter an alle anderen Methoden im Beispiel übergeben wird:This method from the sample application returns the initialized IAzure instance, which is then passed as the first parameter to all other methods in the sample:

/// <summary>
/// Returns an authenticated Azure context using the credentials in the
/// specified auth file.
/// </summary>
/// <param name="authFilePath">The full path to a credentials file on the local filesystem.</param>
/// <returns>Authenticated IAzure context.</returns>
private static IAzure GetAzureContext(string authFilePath)
{            
    IAzure azure;
    ISubscription sub;

    try
    {
        Console.WriteLine($"Authenticating with Azure using credentials in file at {authFilePath}");

        azure = Azure.Authenticate(authFilePath).WithDefaultSubscription();
        sub = azure.GetCurrentSubscription();

        Console.WriteLine($"Authenticated with subscription '{sub.DisplayName}' (ID: {sub.SubscriptionId})");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"\nFailed to authenticate:\n{ex.Message}");

        if (String.IsNullOrEmpty(authFilePath))
        {
            Console.WriteLine("Have you set the AZURE_AUTH_LOCATION environment variable?");
        }

        throw;
    }

    return azure;
}

Weitere Informationen zu den verfügbaren Authentifizierungsmethoden in den .NET-Verwaltungsbibliotheken für Azure finden Sie unter Authentication in Azure Management Libraries for .NET (Authentifizieren in den Azure-Verwaltungsbibliotheken für .NET).For more details about the available authentication methods in the .NET management libraries for Azure, see Authentication in Azure Management Libraries for .NET.

Erstellen einer Containergruppe – einzelner ContainerCreate container group - single container

In diesem Beispiel wird eine Containergruppe mit einem einzelnen Container erstellt.This example creates a container group with a single container.

/// <summary>
/// Creates a container group with a single container.
/// </summary>
/// <param name="azure">An authenticated IAzure object.</param>
/// <param name="resourceGroupName">The name of the resource group in which to create the container group.</param>
/// <param name="containerGroupName">The name of the container group to create.</param>
/// <param name="containerImage">The container image name and tag, for example 'microsoft\aci-helloworld:latest'.</param>
private static void CreateContainerGroup(IAzure azure,
                                         string resourceGroupName, 
                                         string containerGroupName, 
                                         string containerImage)
{
    Console.WriteLine($"\nCreating container group '{containerGroupName}'...");

    // Get the resource group's region
    IResourceGroup resGroup = azure.ResourceGroups.GetByName(resourceGroupName);
    Region azureRegion = resGroup.Region;

    // Create the container group
    var containerGroup = azure.ContainerGroups.Define(containerGroupName)
        .WithRegion(azureRegion)
        .WithExistingResourceGroup(resourceGroupName)
        .WithLinux()
        .WithPublicImageRegistryOnly()
        .WithoutVolume()
        .DefineContainerInstance(containerGroupName + "-1")
            .WithImage(containerImage)
            .WithExternalTcpPort(80)
            .WithCpuCoreCount(1.0)
            .WithMemorySizeInGB(1)
            .Attach()
        .WithDnsPrefix(containerGroupName)
        .Create();

    Console.WriteLine($"Once DNS has propagated, container group '{containerGroup.Name}' will be reachable at http://{containerGroup.Fqdn}");
}

Containergruppe erstellen – mehrere ContainerCreate container group - multiple containers

In diesem Beispiel wird eine Containergruppe mit zwei Containern erstellt: einem Anwendungscontainer und einem Sidecar-Container.This example creates a container group with two containers: an application container and a sidecar container.

/// <summary>
/// Creates a container group with two containers in the specified resource group.
/// </summary>
/// <param name="azure">An authenticated IAzure object.</param>
/// <param name="resourceGroupName">The name of the resource group in which to create the container group.</param>
/// <param name="containerGroupName">The name of the container group to create.</param>
/// <param name="containerImage1">The first container image name and tag, for example 'microsoft\aci-helloworld:latest'.</param>
/// <param name="containerImage2">The second container image name and tag, for example 'microsoft\aci-tutorial-sidecar:latest'.</param>
private static void CreateContainerGroupMulti(IAzure azure,
                                              string resourceGroupName,
                                              string containerGroupName, 
                                              string containerImage1, 
                                              string containerImage2)
{
    Console.WriteLine($"\nCreating multi-container container group '{containerGroupName}'...");

    // Get the resource group's region
    IResourceGroup resGroup = azure.ResourceGroups.GetByName(resourceGroupName);
    Region azureRegion = resGroup.Region;

    // Create the container group
    var containerGroup = azure.ContainerGroups.Define(containerGroupName)
        .WithRegion(azureRegion)
        .WithExistingResourceGroup(resourceGroupName)
        .WithLinux()
        .WithPublicImageRegistryOnly()
        .WithoutVolume()
        .DefineContainerInstance(containerGroupName + "-1")
            .WithImage(containerImage1)
            .WithExternalTcpPort(80)
            .WithCpuCoreCount(0.5)
            .WithMemorySizeInGB(1)
            .Attach()
        .DefineContainerInstance(containerGroupName + "-2")
            .WithImage(containerImage2)
            .WithoutPorts()
            .WithCpuCoreCount(0.5)
            .WithMemorySizeInGB(1)
            .Attach()
        .WithDnsPrefix(containerGroupName)
        .Create();

    Console.WriteLine($"Once DNS has propagated, container group '{containerGroup.Name}' will be reachable at http://{containerGroup.Fqdn}");
}

Asynchrone Containererstellung mit AbrufAsynchronous container create with polling

In diesem Beispiel wird mithilfe der asynchronen Erstellungsmethode eine Containergruppe mit einem einzelnen Container erstellt.This example creates a container group with a single container using the async create method. Anschließend wird die Containergruppe von Azure abgerufen ihr Status ausgegeben, bis er „Wird ausgeführt“ lautet.It then polls Azure for the container group, and outputs the container group's status until its state is "Running."

/// <summary>
/// Creates a container group with a single container asynchronously, and
/// polls its status until its state is 'Running'.
/// </summary>
/// <param name="azure">An authenticated IAzure object.</param>
/// <param name="resourceGroupName">The name of the resource group in which to create the container group.</param>
/// <param name="containerGroupName">The name of the container group to create.</param>
/// <param name="containerImage">The container image name and tag, for example 'microsoft\aci-helloworld:latest'.</param>
private static void CreateContainerGroupWithPolling(IAzure azure,
                                         string resourceGroupName, 
                                         string containerGroupName, 
                                         string containerImage)
{
    Console.WriteLine($"\nCreating container group '{containerGroupName}'...");

    // Get the resource group's region
    IResourceGroup resGroup = azure.ResourceGroups.GetByName(resourceGroupName);
    Region azureRegion = resGroup.Region;

    // Create the container group using a fire-and-forget task
    Task.Run(() =>

        azure.ContainerGroups.Define(containerGroupName)
            .WithRegion(azureRegion)
            .WithExistingResourceGroup(resourceGroupName)
            .WithLinux()
            .WithPublicImageRegistryOnly()
            .WithoutVolume()
            .DefineContainerInstance(containerGroupName + "-1")
                .WithImage(containerImage)
                .WithExternalTcpPort(80)
                .WithCpuCoreCount(1.0)
                .WithMemorySizeInGB(1)
                .Attach()
            .WithDnsPrefix(containerGroupName)
            .CreateAsync()
    );

    // Poll for the container group
    IContainerGroup containerGroup = null;
    while(containerGroup == null)
    {
        containerGroup = azure.ContainerGroups.GetByResourceGroup(resourceGroupName, containerGroupName);

        Console.Write(".");

        SdkContext.DelayProvider.Delay(1000);
    }

    Console.WriteLine();

    // Poll until the container group is running
    while(containerGroup.State != "Running")
    {
        Console.WriteLine($"Container group state: {containerGroup.Refresh().State}");
        
        Thread.Sleep(1000);
    }

    Console.WriteLine($"\nOnce DNS has propagated, container group '{containerGroup.Name}' will be reachable at http://{containerGroup.Fqdn}");
}

Aufgabenbasierte Containergruppe erstellenCreate task-based container group

In diesem Beispiel wird eine Containergruppe mit einem einzelnen aufgabenbasierten Container erstellt.This example creates a container group with a single task-based container. Der Container wird mit der Neustartrichtlinie „Nie“ und einer benutzerdefinierten Befehlszeile konfiguriert.The container is configured with a restart policy of "Never" and a custom command line.

Wenn Sie einen einzelnen Befehl mit mehreren Befehlszeilenargumenten ausführen möchten, z.B. echo FOO BAR, müssen Sie sie als ein Zeichenfolgenarray für die WithStartingCommandLines-Methode angeben.If you want to run a single command with several command-line arguments, for example echo FOO BAR, you must supply them as a string array to the WithStartingCommandLines method. Beispiel: For example:

WithStartingCommandLines("echo", "FOO", "BAR")

Wenn Sie jedoch mehrere Befehle mit (potenziell) mehreren Argumente ausführen möchten, müssen Sie eine Shell ausführen und die verketteten Befehle als Argument übergeben.If, however, you want to run multiple commands with (potentially) multiple arguments, you must execute a shell and pass the chained commands as an argument. Hiermit wird beispielsweise ein echo- sowie ein tail-Befehl ausgeführt:For example, this executes both an echo and a tail command:

WithStartingCommandLines("/bin/sh", "-c", "echo FOO BAR && tail -f /dev/null")

/// <summary>
/// Creates a container group with a single task-based container who's
/// restart policy is 'Never'. If specified, the container runs a custom
/// command line at startup.
/// </summary>
/// <param name="azure">An authenticated IAzure object.</param>
/// <param name="resourceGroupName">The name of the resource group in which to create the container group.</param>
/// <param name="containerGroupName">The name of the container group to create.</param>
/// <param name="containerImage">The container image name and tag, for example 'microsoft\aci-wordcount:latest'.</param>
/// <param name="startCommandLine">The command line that should be executed when the container starts. This value can be <c>null</c>.</param>
private static void RunTaskBasedContainer(IAzure azure,
                                         string resourceGroupName, 
                                         string containerGroupName, 
                                         string containerImage,
                                         string startCommandLine)
{
    // If a start command wasn't specified, use a default
    if (String.IsNullOrEmpty(startCommandLine))
    {
        startCommandLine = "python wordcount.py http://shakespeare.mit.edu/romeo_juliet/full.html";
    }

    // Configure some environment variables in the container which the
    // wordcount.py or other script can read to modify its behavior.
    Dictionary<string, string> envVars = new Dictionary<string, string>
    {
        { "NumWords", "5" },
        { "MinLength", "8" }
    };

    Console.WriteLine($"\nCreating container group '{containerGroupName}' with start command '{startCommandLine}'");

    // Get the resource group's region
    IResourceGroup resGroup = azure.ResourceGroups.GetByName(resourceGroupName);
    Region azureRegion = resGroup.Region;

    // Create the container group
    var containerGroup = azure.ContainerGroups.Define(containerGroupName)
        .WithRegion(azureRegion)
        .WithExistingResourceGroup(resourceGroupName)
        .WithLinux()
        .WithPublicImageRegistryOnly()
        .WithoutVolume()
        .DefineContainerInstance(containerGroupName + "-1")
            .WithImage(containerImage)
            .WithExternalTcpPort(80)
            .WithCpuCoreCount(1.0)
            .WithMemorySizeInGB(1)
            .WithStartingCommandLines(startCommandLine.Split())
            .WithEnvironmentVariables(envVars)
            .Attach()
        .WithDnsPrefix(containerGroupName)
        .WithRestartPolicy(ContainerGroupRestartPolicy.Never)
        .Create();

    // Print the container's logs
    Console.WriteLine($"Logs for container '{containerGroupName}-1':");
    Console.WriteLine(containerGroup.GetLogContent(containerGroupName + "-1"));
}

Containergruppen auflistenList container groups

In diesem Beispiel sind die Containergruppen in einer Ressourcengruppe aufgeführt.This example lists the container groups in a resource group.

/// <summary>
/// Prints the container groups in the specified resource group.
/// </summary>
/// <param name="azure">An authenticated IAzure object.</param>
/// <param name="resourceGroupName">The name of the resource group containing the container group(s).</param>
private static void ListContainerGroups(IAzure azure, string resourceGroupName)
{
    Console.WriteLine($"Listing container groups in resource group '{resourceGroupName}'...");

    foreach (var containerGroup in azure.ContainerGroups.ListByResourceGroup(resourceGroupName))
    {
        Console.WriteLine($"{containerGroup.Name}");
    }
}

Vorhandene Containergruppe abrufenGet an existing container group

In diesem Beispiel wird eine bestimmte Containergruppe abgerufen, die sich in einer Ressourcengruppe befindet. Dann werden einige ihrer Eigenschaften und deren Werte ausgegeben.This example gets a specific container group residing in a resource group and then prints a few of its properties and their values.

/// <summary>
/// Gets the specified container group and then prints a few of its properties and their values.
/// </summary>
/// <param name="azure">An authenticated IAzure object.</param>
/// <param name="resourceGroupName">The name of the resource group containing the container group.</param>
/// <param name="containerGroupName">The name of the container group whose details should be printed.</param>
private static void PrintContainerGroupDetails(IAzure azure, string resourceGroupName, string containerGroupName)
{
    Console.Write($"\nGetting container group details for container group '{containerGroupName}'...");

    IContainerGroup containerGroup = null;
    while (containerGroup == null)
    {
        Console.Write(".");

        containerGroup = azure.ContainerGroups.GetByResourceGroup(resourceGroupName, containerGroupName);

        SdkContext.DelayProvider.Delay(1000);
    }

    Console.WriteLine();
    Console.WriteLine(containerGroup.Name);
    Console.WriteLine("--------------------------------");
    Console.WriteLine($"State:  {containerGroup.State}");
    Console.WriteLine($"FQDN:   {containerGroup.Fqdn}");
    Console.WriteLine($"IP:     {containerGroup.IPAddress}");
    Console.WriteLine($"Region: {containerGroup.RegionName}");
}

Containergruppe löschenDelete a container group

In diesem Beispiel wird eine Containergruppe aus einer Ressourcengruppe gelöscht.This example deletes a container group from a resource group.

/// <summary>
/// Deletes the specified container group.
/// </summary>
/// <param name="azure">An authenticated IAzure object.</param>
/// <param name="resourceGroupName">The name of the resource group containing the container group.</param>
/// <param name="containerGroupName">The name of the container group to delete.</param>
private static void DeleteContainerGroup(IAzure azure, string resourceGroupName, string containerGroupName)
{
    IContainerGroup containerGroup = null;

    while (containerGroup == null)
    {
        containerGroup = azure.ContainerGroups.GetByResourceGroup(resourceGroupName, containerGroupName);

        SdkContext.DelayProvider.Delay(1000);
    }

    Console.WriteLine($"Deleting container group '{containerGroupName}'...");

    azure.ContainerGroups.DeleteById(containerGroup.Id);
}

API-ReferenzAPI reference

BeispieleSamples

Untersuchen Sie weiteren .NET-Beispielcode, den Sie in Ihren Apps verwenden können.Explore more sample .NET code you can use in your apps.