Docker for azure

Docker for azure DEFAULT

Running Docker images on Microsoft Azure

In a previous article, we discussed how to create a new web app and deploy it to an Azure Web App instance. This article goes a step further, creating a Docker image for the web app in order to have more flexibility in management and deployment.

Introducing Docker

Fast-growing business organizations have to deploy new features of their app rapidly if they want to stay on top of the market.

Deploying an app is not always an easy task; how difficult it is depends primarily on how the app is structured and what tools or deployment patterns have been used.

In recent years, the rise of container technologies has changed the game: complex issues related to provisioning infrastructures and software installation dependencies have faded into the background.

There are lots of benefits to using container technologies:

  • Reduced deployment time;
  • Simple host configuration;
  • Multiple apps can run at the same time using different containers;
  • Quick scaling;
  • Savings in infrastructure costs;
  • Containers are based on images, which are simple to create and manage;
  • Containers share the same hardware resources but maintain isolation between them.

Many people prefer using Docker for development (with an isolated environment) or for complex distributed architecture such as Microservices. Containers differ from Virtual Machines, in that thy offer quick startup and share the resources of the host (avoiding unauthorized access between one container and another). On the other hand, containers don’t offer the same hardware isolation as Virtual Machines. Indeed, security can be a reason for blocking the adoption of this method, since containers share the host operating system.

Docker, a company founded by Solomon Hykes, has prevailed among the various container technologies thanks to its complete, ready-to-use ecosystem. With this in place, it is possible to create and distribute an app and execute it either on-premises or in cloud environments. Specifically, the app is compiled into an image using the Docker CLI: starting from a base image with a specific operating system (i.e., Linux or Windows), Docker creates an image which comprises both the app and the execution environment. The compiled image is then stored in a local or remote repository from which it can be downloaded and started. Docker also offers a cloud subscription to DockerHub, which supplies build and collaboration tools to facilitate cloud and container technology adoption.

Docker installation

To use Docker, you need to install the Docker Engine on a developer machine: this page offers a list of supported platforms and the steps required to set up your environment. Note that installation requires a Docker Login account.

After installation, all available toolswill be installed on your machine (stored here), such as the Docker CLI, which helps to spin up the first container using the following command:

docker run hello-world

The following is then displayed:

Docker: The first container execution

Docker runs as root user by default. Unless a name is specified, Docker will automatically assign a random name. Other useful commands include:

  • : run the container in background (detach mode);
  • : get a list of containers;
  • : access a specific image from a Docker Registry (private or public) and store it on the machine (more here);
  • : access available images on the local machine;
  • : starts a specific container;
  • : stops a specific container;
  • : deletes a container that is not in execution;
  • : deletes a container image;
  • : shows details about containers;
  • : shows details about images (including layers);
  • : to create new data volume (more here);
  • : to see image layers;
  • : to create multiple containers at the same time (more here).

The build command helps to create an image for your app:

docker build <PARAMETERS>

Create a Docker image

This section explores the creation of a Docker image, starting with an example found in a previous article.

A Docker image is simply a file composed of different layers created during the build phase. It can contain code, configuration files, libraries, and environment variables. Docker images don’t contain an operating system, but rely on the OS of the host. For this reason, images are categorized by the kernel they use: Linux or Windows. If you are using Linux, you can only run Linux containers. If you are using Windows, you can run both container types. The Docker run command explained in the previous paragraph creates a new Docker Container. Docker images are also created by a Dockerfile. A Docker image is an immutable artifact: it contains many read-only layers dependent on the base images or the Dockerfile definition. Layers function as the building blocks – once a container is started, it has a read/write layer.

Create a Dockerfile

First, you need a Dockerfile – a text file containing a list of steps that execute sequentially during the build process.

Creating a Dockerfile in Visual Studio Code is relatively simple; once the Docker Extension is installed, the command palette helps (via a wizard) to generate a Dockerfile related to your project. These are the settings:

  • Application Platform: ASP.NET Core
  • Operating system: Linux
  • Port: 80, 443
Add a Dockerfile
Select the Application Platform
Select the Operating System
Select the listening ports

At the end of the wizard, Visual Studio Code will show a text file like this:

The contents of a Dockerfile

This file is composed of different sections starting with the FROM keyword. These define the base image from which to build your image (which includes your app). A Dockerfile can contain multiple statements (multi-stage builds). Other available keywords are:

  • : sets the current directory during the build process;
  • : sets the ports to listen to incoming connections at runtime;
  • : copies files;
  • : runs commands during the build;
  • : defines arguments for the entrypoint;
  • : is the command to run when the container starts.

The reason for the multiple sections in this Dockerfile is that Docker images can be built using different configurations. For example, in this Dockerfile, you can choose to use the ‘build‘ section instead of the ‘publish‘ section to compile the application only.

Create a Docker image

To create the image, you can execute the following command in the same directory of the Dockerfile:

docker build -t myfirstapp:v1 .

The ‘t’ parameter stands for tag. This is a fundamental concept of Docker – it helps to organize images, and is composed of the name and the version of your app. Usually, the last built image is identified as the latest. The dot (.) parameter represents the local directory. If you execute the command docker image list you should see the new image on the local repository list. The app can be started on the local pc using the command:

docker run -p 8080:80 -d --name CONTAINER-NAME IMAGE_NAME

However, since we want to start the container on Microsoft Azure, we need to store the image on a container registry such as DockerHub (the default option). As mentioned previously, to install Docker, a Docker Login is required. This allows users access to free repositories on DockerHub.

To create an image for DockerHub, you need to tag it using your DockerHub username:

docker build -t <dockerhubusername>/myfirstapp:v1 .

Finally, push the image using:

docker push <dockerhubusername>/myfirstapp:v1

Start the image on an Azure Web App

To host the container, go to the Microsoft Azure Portal and create an Azure Web App (instructions can be found in the article mentioned in the first paragraph) and select Docker Container for the Publish parameter:

Using Docker in an Azure Web App

Clicking ‘Next Docker‘ will show the Docker image configuration:

Change the configuration to these settings:

  • Options: Single Container;
  • Image Source: Docker Hub;
  • Access Type: Public;
  • Image and Tag: the image name and tag previously created.

Click to ‘Review + Create’ and then click on ‘Create’. Microsoft Azure will start the resource provisioning. Once this is complete, you will be able to navigate to the Azure Web App address to check that the application will run correctly.

Start the image on an Azure Container Instance

Another way to deploy a container in Microsoft Azure is to use an Azure Container instance (ACI). This service allows you to spin up a container in a few steps, guaranteeing perfect isolation for your application and expediting the app‘s scaling. The pricing is also appealing – you pay only for the time the container is up.

To create an Azure Container instance in the Azure portal, create a new resource using the side menu. In the search box, type ‘Container Instances’, and then ‘Create’.

Fill in the ACI settings as in the following image, inserting the name of the image you have created in place of the image name:

Creating an Azure Container Instance

Once this is done, click to ‘Review + Create’ and then on ‘Create’. When the provisioning completes, check the settings page of your ACI for the assigned IP address to visit the running app.

Advanced scenarios

Until now, we have considered only a simple scenario with just one image. Using multiple images that work together requires an orchestrator like Kubernetes to help you provision, manage, and scale. A forthcoming article will cover this topic, focusing on the Azure Kubernetes Service.

Tagged as:DockerMicrosoftMicrosoft Azure


Running your containerized workload on Azure

Over the years, the hosting platform for the applications has undergone many changes. A long time ago, we had started with the mainframes and physical server and then move to the virtualized environments during the late 1990s and early 2000s. Nowadays, public cloud platforms such as Azure and AWS tends to transform application hosting platforms by developing many of Platform-as-a-Service and Software-as-a-Service solutions. At the same time, modernization of the traditional computing services, such as Virtual Machine Scale Sets, bring the cloud-native capabilities to the virtual machines. That gives you the possibility to have a scalable application, ready to respond to the unpredictable workload.

One of the hosting platforms for application, that is in expansion over the last few years are containers. Containers allow you to package up code and all its dependencies and offer an isolated environment for running applications. The container layer is abstracted from the host environment, which they run. Very often, containers are compared to virtual machines, and like virtual machines, containers allow you to package your application with all needed libraries and dependencies. Although virtual machines and containers are similar, there is a lot of essential differences. Unlike the virtual machines which for virtualization occurs on the hardware level, containers virtualization is at the operating system level, which gives the possibility to run multiple containers atop on the OS kernel. Because of that, containers have benefits, and some of them are:

  • Less overhead: Containers are lightweight and require fewer system resources than virtual machine environments 
  • Better portability: Containers can be deployed quickly and efficiently to different OS and hardware platforms, as well as on various public cloud platforms. 
  • Efficiency: Application that is running on containers can be quickly deployed and scaled 
  • Continuous development: Containers support agile and DevOps efforts to accelerate the application lifecycle 

How to run containers on Azure? 

Like other public cloud providers, Microsoft Azure offers various sets of options to run your containerized application in Azure. 

One of the options is to run Docker on Azure Virtual Machines. Docker is a set of services that uses OS-level virtualization to deliver containers. Docker is fully supported by Microsoft from late 2015 when Windows Server integrate Docker. Of course, Microsoft Azure is part of that integration list, and there are a few options to run Docker on Azure Virtual Machines. 

The second option to run your containers on Azure is Azure Container Instances (ACI). Azure Container 

Instances are part of the Azure PaaS family that gives you the possibility to run containers in Azure without managing the infrastructure that hosts containers. This approach brings full cloud-native benefits due to the integration of ACI with most of the other Azure services. 

Azure Kubernetes Service (AKS), as a third option, is a fully managed Kubernetes cluster, that makes the process of deploying and maintaining containerized applications simplified. With AKS, your Azure Container Instances are utilized and ready for deployment at scale. Elastic provisioning, end-to-end deployment, advanced identity, and security, supported CI/CD pipelines, and more features are some of the Azure Kubernetes Service benefits. 

First „containerized“ steps in Azure 

The very first step of deploying your containerized application in Azure is deploying Azure Virtual Machine with Docker, for preparing images and running your containers. Your containers could be hosted on Azure Virtual Machine with Docker, as well as you can use that virtual machines for making custom containers and pushing them to the container registry. 

Installing Docker on Azure Virtual Machine is a pretty simple task. The recommended way is to install Docker Extension for Azure VM, instead of manually installing all needed Docker components on the virtual machine. For the installation of the Docker Extension, you can use Azure CLI, Azure PowerShell, as well as the ARM templates. By following commands, you can install Docker Extension to the existing virtual machine.

Azure CLI 

az vm extension set --vm-name docker-vm --resource-group docker-rg --name DockerExtension --publisher Microsoft.Azure.Extensions --version 1.1 

Azure PowerShell 

Set-AzVMExtension -ResourceGroupName docker-rg -VMName docker-vm -Location westus2 -Publisher Microsoft.Azure.Extensions -ExtensionType DockerExtension -  Name DockerExtension -TypeHandlerVersion 1.1 

ARM Templates  

            "type": "Microsoft.Compute/virtualMachines/extensions",
            "name": "[concat(parameters('virtualMachineName'), '/DockerExtension')]",
            "apiVersion": "2019-07-01",
            "location": "[resourceGroup().location]",
            "dependsOn": [
                "[concat('Microsoft.Compute/virtualMachines/', parameters('virtualMachineName'))]"
            "properties": {
                "publisher": "Microsoft.Azure.Extensions",
                "type": "DockerExtension",
                "typeHandlerVersion": "1.1",
                "autoUpgradeMinorVersion": true,
                "settings": {}

Once you install Docker Extension on the Azure Virtual Machine, you can see that Docker and Docker-Compose are installed. At the moment, only CoreOS 899 and higher, Ubuntu 13 and higher, CentOS 7.1 and higher and Red Hat Enterprise Linux (RHEL) 7.1 and higher, are supported for this Docker Extension. 

Prepare the „hub“ for your container images – Azure Container Registry 

If all steps for configuring Docker on Azure VM are finished, you are ready to making container images or run your containers in Azure. Hosting of your containers on Azure Virtual Machine with Docker is not in the spirit of the cloud-native design. Still, a virtual machine with Docker can be „station“ to develop and maintain your container images. Once prepared, container images can be pushed to the Azure Container Registry, to store images in Azure close to the Azure Container Instances or Azure Kubernetes Service.  

Azure Container Registry (ACR) is the fully managed, private hub for your container images, that allows you to build, store, and manage container images and artefacts for all types of container deployments, based on the open-source Docker Registry 2.0. The key features of the ACR are: 

  • ACR SKUs – Different SKUs (Basic, Standard, Premium) offers various types of functionalities and different pricing as well 
  • Security and access – For log in to ACR, you can use Azure CLI or the standard docker login command. Images are transferred to ACR over HTTPS and support TLS to secure client connections. 
  • RBAC Integration – Role-based access control (RBAC) uses to assign users or systems fine-grained permissions to a registry. 
  • Supported Images – Each container image is a read-only snapshot fo a Docker-compatible container. 
  • Automated Builds – Azure Container Registry Tasks (ACR Tasks) are used to streamline building, testing, to push and to deploy images to Azure. 

Installing of Azure Container Registry is easy and quicky and can be completed by using any of Azure administration tools. Defining the unique registry name is an essential part of creating the Azure Container Registry because the name is publicly available. The suffix is adding to your container registry name. Also, if you want to use docker login commands to authenticate to the ACR, the admin user needs to be enabled. 

How to run containers on Azure

Once created, ACR is ready to store your container images. Access credentials, as well as other configurations, can be found in the pane of Azure Container Registry. 

How to run containers on Azure

When you collect all needed access parameters (login server name, username, password), you can connect your virtual machine with Docker to Azure Container Registry, and push container images to the registry. 

How to run containers on Azure 4

Store your images in Azure 

Azure Virtual Machine with Docker is ready, as well as the Azure container registry. What you wait now? Prepare your customized container image and push them to the Azure Container Registry and make the container deployment process more comfortable. Images that you want to push to Azure Container Registry needs to be tagged in format <login server name>/<repository>/<image name>. 

How to run containers on Azure 5

When this task is completed, you can see your images in Azure Container Registry and use them for deployment in the Azure Container Instances. 

How to run containers on Azure 6

What are the next steps? 

 Good job. A customized container image is now ready to be served to the Azure Container Instances directly from Azure Container Registry. Those tasks are a just start of the container journey, but the real benefits of using containers in Azure you will be able to see in the following posts when we will talk about Azure Container Instances. 

Get in touch today

Consultation with our experts is free of charge. Book a call today.

  1. Mack exhaust brackets
  2. Roblox show unavailable items
  3. Disable car mode htc
  4. Atk fr 14 review
  5. Bb gun 22 caliber

Home / Deploying a Docker based web application to Azure App Service


A Docker container image is a lightweight, standalone, executable package of software that includes everything needed to run an application: code, runtime, system tools, system libraries and settings.

This lab outlines the process to build custom Docker images of an ASP.NET Core application, push those images to a private repository in Azure Container Registry (ACR). These images will be used to deploy the application to the Docker containers in the Azure App Service (Linux) using Azure DevOps.

The Web App for Containers allows the creation of custom Docker container images, easily deploy and then run them on Azure. Combination of Azure DevOps and Azure integration with Docker will enable the following:

  1. Build custom Docker images using Azure DevOps Hosted Linux agent

  2. Push and store the Docker images in a private repository

  3. Deploy and run the images inside the Docker Containers

Before you begin

  1. Refer the Getting Started page to know the prerequisites for this lab.

  2. Click the Azure DevOps Demo Generator link and follow the instructions in Getting Started page to provision the project to your Azure DevOps.

Setting up the Environment

  1. The following resources needs to be configured for this lab:

    • Azure Container Registry

    • Azure Web App for Containers

    • Azure SQL Server Database

  2. Launch the Azure Cloud Shell from the Azure portal and choose Bash.

  3. Create Azure Container Registry:

    i. Create a Resource Group. Replace with the region of your choosing, for example eastus.

    ii. Create ACR( Azure Container Registry)

    Important: Enter a unique ACR name. ACR name may contain alpha numeric characters only and must be between 5 and 50 characters

  4. Create Azure Web App for Containers:

    i. Create a Linux App Service Plan:

    ii. Create a custom Docker container Web App: To create a web app and configuring it to run a custom Docker container, run the following command:

  5. Create Azure SQL server and Database: Create an Azure SQL server.

    Create a database

    Important: Enter a unique SQL server name. Since the Azure SQL Server name does not support UPPER / Camel casing naming conventions, use lowercase for the DB Server Name field value.

  6. Create a firewall rule for SQL server that allows access from Azure services

  7. Update web app’s connection string

    Update your app service name and SQL server name in the above command. This command will add a connection string to your app service with the name .

  8. Navigate to the resource group. You can see that the following components are provisioned.

    Post Azure Deployment

  9. Click on the mhcdb SQL database and make a note of the server details under the header Server name.

    DB Server URL

  10. Navigate back to the resource group. Click on the container registry and make a note of the server details under the header Login server. These details will be required in the Exercise 2.


Exercise 1: Configure Continuous Integration (CI) and Continuous Delivery (CD)

Now that the required resources are provisioned, the Build and the Release definition need to be manually configured with the new information. The dacpac will also be deployed to the mhcdb database so that the schema and data is configured for the backend.

  1. Navigate to the Pipelines option under the Pipelines tab. Select the build definition , and select the Edit option.


  2. In the Run services, Build services and Push services tasks, authorize (only for the first task) the Azure subscription and update Azure Container Registry with the endpoint component from the dropdown and click on Save.




  3. Navigate to the Releases section under the Pipelines tab. Select the release definition , click Edit option and then click on the Tasks section.


    Release Tasks

  4. The usage details of the agents are provided below:

    AgentsUsage Details
    DB deploymentThe Hosted VS2017 agent is used to deploy the database
    Web App deploymentThe Hosted Ubuntu 1604 agent is used to deploy the application to the Linux Web App
  5. Under the Execute Azure SQL: DacpacTask section, select the Azure Subscription from the dropdown.

    Execute Azure SQL: DacpacTask: This task will deploy the dacpac to the mhcdb database so that the schema and data are configured for the backend.

    Update DB Task

  6. Under Azure App Service Deploy task, update the Azure subscription and Azure App Service name with the endpoint components from the dropdown.

    Azure App Service Deploy will pull the appropriate docker image corresponding to the BuildID from repository specified, and then deploys the image to the Linux App Service.

    Update repository

  7. Click on the Variables section, update the ACR details and the SQLserver details with the details noted earlier while the configuration of the environment and click on the Save button.

    Update variables

    The Database Name is set to mhcdb, the Server Admin Login is set to sqladmin and the Password is set currently to P2ssw0rd1234.

Exercise 2: Initiate the CI Build and Deployment through code commit

In this exercise, the source code will be modified to trigger the CI-CD.

  1. Click on Files section under the Repos tab, and navigate to the folder and open the file for editing.

    Edit code

  2. Modify the text JOIN US to CONTACT US on the line number 28 and then click on the Commit button. This action would initiate an automatic build for the source code.

    Line Edit

  3. Click on Pipelines tab, you will see build is queued. Double click on Build # or Commit to view the build in progress.



  4. The Build will generate and push the docker image of the web application to the Azure Container Registry. Once the build is completed, the build summary will be displayed.

    Build Summary

  5. Navigate to the Azure Portal and click on the App Service that was created at the beginning of this lab. Select the Container Settings option and provide the information as suggested and then click the Save button.

    FieldValue to be provided
    Image SourceSelect the value Azure Container Registry
    RegistrySelect the registry value from the dropdown
    imageSelect the value myhealth.web
    TagSelect the value latest. This is required to map Azure Container Registry with the Web App.

    Update registry

    Tip: The Continuous Deployment can be configured to deploy the web app to the designated server whenever a new docker image is pushed to the registry on the Azure portal itself. However, setting up an Azure DevOps CD pipeline will provide better flexibility and additional controls (approvals, release gates, etc.) for the application deployment.

  6. Navigate to the Azure Container registry created and then select the Repositories option to view the generated docker images.


  7. Navigate to the Releases section under Pipelines tab, and double-click on the latest release displayed on the page. Click on Logs to view the details of the release in progress.

    Release Progress

    Release Progress

    Release Progress

  8. The release will deploy the docker image to the App Service based on the BuildID tagged with the docker image. Once the release is completed, the release Logs will be displayed.


  9. Navigate back to the Azure Portal and click on the Overview section of the App Service. Click on the link displayed under the URL field to browse the application and view the changes.

    Web app URL

    Final Result

  10. Use the credentials Username: and Password: to login to the HealthClinic web application.


With Azure DevOps and Azure, we have configured a dockerized application by leveraging docker capabilities enabled on Azure DevOps Ubuntu Hosted Agent.

Build, Run, \u0026 Continuously Deploy Docker Containers to Azure App Service

Deploying Docker containers on Azure

Estimated reading time: 19 minutes


The Docker Azure Integration enables developers to use native Docker commands to run applications in Azure Container Instances (ACI) when building cloud-native applications. The new experience provides a tight integration between Docker Desktop and Microsoft Azure allowing developers to quickly run applications using the Docker CLI or VS Code extension, to switch seamlessly from local development to cloud deployment.

In addition, the integration between Docker and Microsoft developer technologies allow developers to use the Docker CLI to:

  • Easily log into Azure
  • Set up an ACI context in one Docker command allowing you to switch from a local context to a cloud context and run applications quickly and easily
  • Simplify single container and multi-container application development using the Compose specification, allowing a developer to invoke fully Docker-compatible commands seamlessly for the first time natively within a cloud container service

Also see the full list of container features supported by ACI and full list of compose features supported by ACI.


To deploy Docker containers on Azure, you must meet the following requirements:

  1. Download and install the latest version of Docker Desktop.

    Alternatively, install the Docker Compose CLI for Linux.

  2. Ensure you have an Azure subscription. You can get started with an Azure free account.

Run Docker containers on ACI

Docker not only runs containers locally, but also enables developers to seamlessly deploy Docker containers on ACI using or deploy multi-container applications defined in a Compose file using the command.

The following sections contain instructions on how to deploy your Docker containers on ACI. Also see the full list of container features supported by ACI.

Log into Azure

Run the following commands to log into Azure:

This opens your web browser and prompts you to enter your Azure login credentials. If the Docker CLI cannot open a browser, it will fall back to the Azure device code flow and lets you connect manually. Note that the Azure command line login is separated from the Docker CLI Azure login.

Alternatively, you can log in without interaction (typically in scripts or continuous integration scenarios), using an Azure Service Principal, with


Logging in through the Azure Service Provider obtains an access token valid for a short period (typically 1h), but it does not allow you to automatically and transparently refresh this token. You must manually re-login when the access token has expired when logging in with a Service Provider.

You can also use the option alone to specify a tenant, if you have several ones available in Azure.

Create an ACI context

After you have logged in, you need to create a Docker context associated with ACI to deploy containers in ACI. Creating an ACI context requires an Azure subscription, a resource group, and a region. For example, let us create a new context called :

This command automatically uses your Azure login credentials to identify your subscription IDs and resource groups. You can then interactively select the subscription and group that you would like to use. If you prefer, you can specify these options in the CLI using the following flags: , , and .

If you don’t have any existing resource groups in your Azure account, the command creates one for you. You don’t have to specify any additional options to do this.

After you have created an ACI context, you can list your Docker contexts by running the command:

Run a container

Now that you’ve logged in and created an ACI context, you can start using Docker commands to deploy containers on ACI.

There are two ways to use your new ACI context. You can use the flag with the Docker command to specify that you would like to run the command using your newly created ACI context.

Or, you can change context using to select the ACI context to be your focus for running Docker commands. For example, we can use the command to deploy an Nginx container:

After you’ve switched to the context, you can use to list your containers running on ACI.

In the case of the demonstration Nginx container started above, the result of the ps command will display in column “PORTS” the IP address and port on which the container is running. For example, it may show , and you can view the Nginx welcome page by browsing .

To view logs from your container, run:

To execute a command in a running container, run:

To stop and remove a container from ACI, run:

You can remove containers using . To remove a running container, you must use the flag, or stop the container using before removing it.


The semantics of restarting a container on ACI are different to those when using a local Docker context for local development. On ACI, the container will be reset to its initial state and started on a new node. This includes the container’s filesystem so all state that is not stored in a volume will be lost on restart.

Running Compose applications

You can also deploy and manage multi-container applications defined in Compose files to ACI using the command. All containers in the same Compose application are started in the same container group. Service discovery between the containers works using the service name specified in the Compose file. Name resolution between containers is achieved by writing service names in the file that is shared automatically by all containers in the container group.

Also see the full list of compose features supported by ACI.

  1. Ensure you are using your ACI context. You can do this either by specifying the flag or by setting the default context using the command .

  2. Run and to start and then stop a full Compose application.

By default, uses the file in the current folder. You can specify the working directory using the --workdir flag or specify the Compose file directly using .

You can also specify a name for the Compose application using the flag during deployment. If no name is specified, a name will be derived from the working directory.

Containers started as part of Compose applications will be displayed along with single containers when using . Their container ID will be of the format: . These containers cannot be stopped, started, or removed independently since they are all part of the same ACI container group. You can view each container’s logs with . You can list deployed Compose applications with . This will list only compose applications, not single containers started with . You can remove a Compose application with .


The current Docker Azure integration does not allow fetching a combined log stream from all the containers that make up the Compose application.

Updating applications

From a deployed Compose application, you can update the application by re-deploying it with the same project name: .

Updating an application means the ACI node will be reused, and the application will keep the same IP address that was previously allocated to expose ports, if any. ACI has some limitations on what can be updated in an existing application (you will not be able to change CPU/memory reservation for example), in these cases, you need to deploy a new application from scratch.

Updating is the default behavior if you invoke on an already deployed Compose file, as the Compose project name is derived from the directory where the Compose file is located by default. You need to explicitly execute before running again in order to totally reset a Compose application.

Releasing resources

Single containers and Compose applications can be removed from ACI with the command. The command removes deployments that are not currently running. To remove running depoyments, you can specify . The option lists deployments that are planned for removal, but it doesn’t actually remove them.

Exposing ports

Single containers and Compose applications can optionally expose ports. For single containers, this is done using the () flag of the command : .

For Compose applications, you must specify exposed ports in the Compose file service definition:


ACI does not allow port mapping (that is, changing port number while exposing port). Therefore, the source and target ports must be the same when deploying to ACI.

All containers in the same Compose application are deployed in the same ACI container group. Different containers in the same Compose application cannot expose the same port when deployed to ACI.

By default, when exposing ports for your application, a random public IP address is associated with the container group supporting the deployed application (single container or Compose application). This IP address can be obtained when listing containers with or using .

DNS label name

In addition to exposing ports on a random IP address, you can specify a DNS label name to expose your application on an FQDN of the form: .

You can set this name with the flag when performing a , or by using the field in the Compose file when performing a :


The domain of a Compose application can only be set once, if you specify the for several services, the value must be identical.

The FQDN must be available.

Using Azure file share as volumes in ACI containers

You can deploy containers or Compose applications that use persistent data stored in volumes. Azure File Share can be used to support volumes for ACI containers.

Using an existing Azure File Share with storage account name and file share name , you can specify a volume in your deployment command as follows:

The runtime container will see the file share content in .

In a Compose application, the volume specification must use the following syntax in the Compose file:


The volume short syntax in Compose files cannot be used as it is aimed at volume definition for local bind mounts. Using the volume driver and driver option syntax in Compose files makes the volume definition a lot more clear.

In single or multi-container deployments, the Docker CLI will use your Azure login to fetch the key to the storage account, and provide this key with the container deployment information, so that the container can access the volume. Volumes can be used from any file share in any storage account you have access to with your Azure login. You can specify (read/write) or (read only) when mounting the volume ( is the default).

Managing Azure volumes

To create a volume that you can use in containers or Compose applications when using your ACI Docker context, you can use the command, and specify an Azure storage account name and the file share name:

By default, if the storage account does not already exist, this command creates a new storage account using the Standard LRS as a default SKU, and the resource group and location associated with your Docker ACI context.

If you specify an existing storage account, the command creates a new file share in the existing account:

Alternatively, you can create an Azure storage account or a file share using the Azure portal, or the command line.

You can also list volumes that are available for use in containers or Compose applications:

To delete a volume and the corresponding Azure file share, use the command:

This permanently deletes the Azure file share and all its data.

When deleting a volume in Azure, the command checks whether the specified file share is the only file share available in the storage account. If the storage account is created with the command, also deletes the storage account when it does not have any file shares. If you are using a storage account created without the command (through Azure portal or with the command line for example), does not delete the storage account, even when it has zero remaining file shares.

Environment variables

When using , you can pass the environment variables to ACI containers using the flag. For Compose applications, you can specify the environment variables in the Compose file with the or service field, or with the command line flag.

Health checks

You can specify a container health checks using either the prefixed flags with , or in a Compose file with the section of the service.

Health checks are converted to ACI s. ACI runs the health check command periodically, and if it fails, the container will be terminated.

Health checks must be used in addition to restart policies to ensure the container is then restarted on termination. The default restart policy for is which will not restart the container. The default restart policy for Compose is which will always try restarting the service containers.

Example using :

Example using Compose files:

Private Docker Hub images and using the Azure Container Registry

You can deploy private images to ACI that are hosted by any container registry. You need to log into the relevant registry using before running or . The Docker CLI will fetch your registry login for the deployed images and send the credentials along with the image deployment information to ACI. In the case of the Azure Container Registry, the command line will try to automatically log you into ACR from your Azure login. You don’t need to manually login to the ACR registry first, if your Azure login has access to the ACR.

Using ACI resource groups as namespaces

You can create several Docker contexts associated with ACI. Each context must be associated with a unique Azure resource group. This allows you to use Docker contexts as namespaces. You can switch between namespaces using .

When you run the command, it only lists containers in your current Docker context. There won’t be any contention in container names or Compose application names between two Docker contexts.

Install the Docker Compose CLI on Linux

The Docker Compose CLI adds support for running and managing containers on Azure Container Instances (ACI).

Install Prerequisites

Install script

You can install the new CLI using the install script:

Manual install

You can download the Docker ACI Integration CLI from the latest release page.

You will then need to make it executable:

To enable using the local Docker Engine and to use existing Docker contexts, you must have the existing Docker CLI as somewhere in your . You can do this by creating a symbolic link from the existing Docker CLI:


The environment variable is a colon-separated list of directories with priority from left to right. You can view it using . You can find the path to the existing Docker CLI using . You may need root permissions to make this link.

On a fresh install of Ubuntu 20.04 with Docker Engine already installed:

You can verify that this is working by checking that the new CLI works with the default context:

To make this CLI with ACI integration your default Docker CLI, you must move it to a directory in your with higher priority than the existing Docker CLI.

Again, on a fresh Ubuntu 20.04:

Supported commands

After you have installed the Docker ACI Integration CLI, run to see the current list of commands.


To remove the Docker Azure Integration CLI, you need to remove the binary you downloaded and from your . If you installed using the script, this can be done as follows:


Thank you for trying out Docker Azure Integration. Your feedback is very important to us. Let us know your feedback by creating an issue in the compose-cli GitHub repository.

Docker, Azure, Integration, ACI, context, Compose, cli, deploy, containers, cloud

For azure docker

"Well, Duc, Nelk. where did the February schoolchild get money for irises. toffee, and that is not enough.

Docker (Part 3) : CI/CD pipeline for Docker Container - Azure DevOps for Docker Containers

With vodka, champagne and cigarettes, the evening acquired an increasingly pronounced erotic tinge. The glamor of desire rolled in waves, now increasing, now weakening. The dancers from the group performed a few more numbers, already more erotic, they danced the cancan, and one girl's corset accidentally loosened and the.

You will also like:

I really didn't want to. Our wonderful meeting took place after a long break. We were both already exhausted in thirst for each other. They strove for each other, restraining themselves with the last bit of strength.

1198 1199 1200 1201 1202