Bibliotecas de Azure Container Instances para .NET
Use las bibliotecas de Microsoft Azure Container Instances para .NET para crear y administrar instancias de contenedor de Azure. Para más información, consulte la Introducción a Azure Container Instances.
Biblioteca de administración
Use la biblioteca de administración para crear y administrar instancias de contenedor en Azure.
Instale el paquete NuGet directamente desde la Consola del Administración de paquetes de Visual Studio o con la CLI de .NET Core.
Administrador de paquetes de Visual Studio
Install-Package Microsoft.Azure.Management.ContainerInstance.Fluent
dotnet add package Microsoft.Azure.Management.ContainerInstance.Fluent
Ejemplo de código fuente
Si desea ver los ejemplos de código siguientes en contexto, los encontrará en el repositorio de GitHub siguiente:
Azure-Samples/aci-docs-sample-dotnet
Authentication
Una de las maneras más fáciles de autenticar clientes de SDK es con la autenticación basada en archivo. La autenticación basada en archivo analiza un archivo de credenciales al crear una instancia del objeto de cliente IAzure que, después, usa esas credenciales al autenticarse con Azure. Para usar la autenticación basada en archivo
Cree un archivo de credenciales con la CLI de Azure o Cloud Shell:
az ad sp create-for-rbac --sdk-auth > my.azureauthSi usa Cloud Shell para generar el archivo de credenciales, copie su contenido en un archivo local al que la aplicación de .NET pueda tener acceso.
Establezca la variable de entorno
AZURE_AUTH_LOCATIONen la ruta de acceso completa del archivo de credenciales generado. Por ejemplo (en el shell de Bash):export AZURE_AUTH_LOCATION=/home/yourusername/my.azureauth
Después de crear el archivo de credenciales y rellenar la entorno variable AZURE_AUTH_LOCATION, use el método Azure.Authenticate para inicializar el objeto de cliente IAzure. El proyecto de ejemplo obtiene en primer lugar el valor AZURE_AUTH_LOCATION y, después, llama a un método que devuelve un objeto de cliente IAzure inicializado:
// 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);
Este método de la aplicación de ejemplo devuelve la instancia de IAzure inicializada que, a continuación, se pasa como primer parámetro a todos los otros métodos del ejemplo:
/// <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;
}
Para más información acerca de los métodos de autenticación disponibles en las bibliotecas de administración de .NET para Azure, consulte Autenticación con las bibliotecas de administración de Azure para .NET.
Creación de un grupo de contenedores: un solo contenedor
En este ejemplo se crea un grupo de contenedores con un solo contenedor.
/// <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}");
}
Creación de un grupo de contenedores: varios contenedores
En este ejemplo se crea un grupo de contenedores con dos contenedores: un contenedor de aplicaciones y un contenedor asociado.
/// <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}");
}
Creación asincrónica de un contenedor con sondeo
En este ejemplo se crea un grupo de contenedores con un solo contenedor con el método de creación asincrónica. Después, sondea el grupo de contenedores en Azure y proporciona el estado del grupo de contenedores hasta que el estado es "En ejecución".
/// <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}");
}
Creación de un grupo de contenedores basado en tareas
En este ejemplo se crea un grupo de contenedores con un solo contenedor basado en tareas. El contenedor se configura con una directiva de reinicio "Never" y una línea de comandos personalizada.
Si desea ejecutar un único comando con varios argumentos de línea de comandos, por ejemplo echo FOO BAR, debe proporcionarlos como una matriz de cadenas al método WithStartingCommandLines. Por ejemplo:
WithStartingCommandLines("echo", "FOO", "BAR")
En cambio, si desea ejecutar varios comandos con varios argumentos posibles, debe ejecutar un shell y pasar los comandos encadenados como argumento. Por ejemplo, esto ejecuta los comandos echo y tail:
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"));
}
Enumeración de grupos de contenedores
En este ejemplo se enumeran los grupos de contenedores de un grupo de recursos.
/// <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}");
}
}
Obtención de un grupo de contenedores existente
En este ejemplo se obtiene un grupo de contenedores específico que reside en un grupo de recursos y, a continuación, se imprimen algunas de sus propiedades y sus valores.
/// <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}");
}
Eliminación de un grupo de contenedores
En este ejemplo se elimina un grupo de contenedores de un grupo de recursos.
/// <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);
}
Referencia de API
Ejemplos
El código fuente de los ejemplos anteriores se encuentra en GitHub:
Más ejemplos de código de Azure Container Instances:
Explore más código de .NET de ejemplo que puede usar en sus aplicaciones.
Azure SDK for .NET
Comentarios
Próximamente: A lo largo de 2024 iremos eliminando gradualmente GitHub Issues como mecanismo de comentarios sobre el contenido y lo sustituiremos por un nuevo sistema de comentarios. Para más información, vea: https://aka.ms/ContentUserFeedback.
Enviar y ver comentarios de