Develop Azure Compute Solutions (25-30%)

 Create ARM templates

Create ARM templates

Create and deploy ARM templates by using the Azure portal 

Learn how to generate an Azure Resource Manager template (ARM template) using the Azure portal, and the process of editing and deploying the template from the portal. ARM templates are JSON files that define the resources you need to deploy for your solution. To understand the concepts associated with deploying and managing your Azure solutions, see template deployment overview.

Generate a template using the portal

Creating an ARM template from scratch is not an easy task, especially if you are new to Azure deployment and you are not familiar with the JSON format. Using the Azure portal, you can configure a resource, for example an Azure Storage account. Before you deploy the resource, you can export your configuration into a template. You can save the template and reuse it in the future.

Many experienced template developers use this method to generate templates when they try to deploy Azure resources that they are not familiar with. For more information about exporting templates by using the portal, see Export resource groups to templates. The other way to find a working template is from Azure Quickstart templates.

1. In a web browser, go to the Azure portal and sign in.

2. From the Azure portal menu, select Create a resource.

   

3. Select Storage > Storage account.

   

4. Enter the following information:

   TABLE 1

   Name	Value
   Resource group	Select Create new, and specify a resource group name of your choice. On the screenshot, the resource group name is mystorage1016rg. Resource group is a container for Azure resources. Resource group makes it easier to manage Azure resources.
   Name	Give your storage account a unique name. The storage account name must be unique across all of Azure, and it contain only lowercase letters and numbers. Name must be between 3 and 24 characters. If you get an error message saying "The storage account name 'mystorage1016' is already taken", try using <your name>storage<Today's date in MMDD>, for example johndolestorage1016. For more information, see Naming rules and restrictions.

   You can use the default values for the rest of the properties.

   

1. Select Review + create on the bottom of the screen. Do not select Create in the next step.

2. Select Download a template for automation on the bottom of the screen. The portal shows the generated template:

   

   The main pane shows the template. It is a JSON file with six top-level elements - schema, contentVersion, parameters, variables, resources, and output. For more information, see Understand the structure and syntax of ARM templates

1. There are eight parameters defined. One of them is called storageAccountName. The second highlighted part on the previous screenshot shows how to reference this parameter in the template. In the next section, you edit the template to use a generated name for the storage account.

   In the template, one Azure resource is defined. The type is Microsoft.Storage/storageAccounts. Take a look of how the resource is defined, and the definition structure.

2. Select Download from the top of the screen.

3. Open the downloaded zip file, and then save template.json to your computer. In the next section, you use a template deployment tool to edit the template.

4. Select the Parameter tab to see the values you provided for the parameters. Write down these values, you need them in the next section when you deploy the template.

Using both the template file and the parameters file, you can create a resource, in this tutorial, an Azure storage account.

Edit and deploy the template

The Azure portal can be used to perform some basic template editing. In this quickstart, you use a portal tool called Template Deployment. Template Deployment is used in this tutorial so you can complete the whole tutorial using one interface - the Azure portal. To edit a more complex template, consider using Visual Studio Code, which provides richer edit functionalities.

Azure requires that each Azure service has a unique name. The deployment could fail if you entered a storage account name that already exists. To avoid this issue, you modify the template to use a template function call uniquestring() to generate a unique storage account name.

1. From the Azure portal menu, in the search box, type deploy, and then select Deploy a custom template.

   

2. Select Build your own template in the editor.

3. Select Load file, and then follow the instructions to load template.json you downloaded in the last section.

4. Make the following three changes to the template:

   

   • Remove the storageAccountName parameter as shown in the previous screenshot.

   • Add one variable called storageAccountName as shown in the previous screenshot:

     JSON

     "storageAccountName": "[concat(uniqueString(subscription().subscriptionId), 'storage')]"
     

     Two template functions are used here: concat() and uniqueString().

   • Update the name element of the Microsoft.Storage/storageAccounts resource to use the newly defined variable instead of the parameter:

     JSON

     "name": "[variables('storageAccountName')]",
     

     The final template shall look like:

     JSON

     {
       "$schema": "http://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
       "contentVersion": "1.0.0.0",
       "parameters": {
         "location": {
           "type": "string"
         },
         "accountType": {
           "type": "string"
         },
         "kind": {
           "type": "string"
         },
         "accessTier": {
           "type": "string"
         },
         "minimumTlsVersion": {
           "type": "string"
         },
         "supportsHttpsTrafficOnly": {
          "type": "bool"
         },
         "allowBlobPublicAccess": {
           "type": "bool"
         }
       },
       "variables": {
         "storageAccountName": "[concat(uniqueString(subscription().subscriptionId), 'storage')]"
       },
       "resources": [
         {
           "name": "[variables('storageAccountName')]",
           "type": "Microsoft.Storage/storageAccounts",
           "apiVersion": "2019-06-01",
           "location": "[parameters('location')]",
           "properties": {
             "accessTier": "[parameters('accessTier')]",
             "minimumTlsVersion": "[parameters('minimumTlsVersion')]",
             "supportsHttpsTrafficOnly": "[parameters('supportsHttpsTrafficOnly')]",
             "allowBlobPublicAccess": "[parameters('allowBlobPublicAccess')]"
           },
           "dependsOn": [],
           "sku": {
             "name": "[parameters('accountType')]"
           },
           "kind": "[parameters('kind')]",
           "tags": {}
         }
       ],
       "outputs": {}
     }
     

5. Select Save.

6. Enter the following values:

   TABLE 2

   Name	Value
   Resource group	Select the resource group name you created in the last section.
   Region	Select a location for the resource group. For example, Central US.
   Location	Select a location for the storage account. For example, Central US.
   Account Type	Enter Standard_LRS for this quickstart.
   Kind	Enter StorageV2 for this quickstart.
   Access Tier	Enter Hot for this quickstart.
   Minimum Tls Version	Enter TLS1_0.
   Supports Https Traffic Only	Select true for this quickstart.
   Allow Blob Public Access	Select false for this quickstart.

7. Select Review + create.

8. Select Create.

9. Select the bell icon (notifications) from the top of the screen to see the deployment status. You shall see Deployment in progress. Wait until the deployment is completed.

   

10. Select Go to resource group from the notification pane. You shall see a screen similar to:

    

    You can see the deployment status was successful, and there is only one storage account in the resource group. The storage account name is a unique string generated by the template. To learn more about using Azure storage accounts, see Quickstart: Upload, download, and list blobs using the Azure portal.

Create a container image for deployment to Azure Container Instances

    Azure Container Instances enables deployment of Docker containers onto Azure infrastructure without provisioning any virtual machines or adopting a higher-level service.

Docker overview

Docker is an open platform for developing, shipping, and running applications. Docker enables you to separate your applications from your infrastructure so you can deliver software quickly. With Docker, you can manage your infrastructure in the same ways you manage your applications. By taking advantage of Docker’s methodologies for shipping, testing, and deploying code quickly, you can significantly reduce the delay between writing code and running it in production.

--------------------- Note ---------------------------------------------

 Important

Because the Azure Cloud shell does not include the Docker daemon, you must install both the Azure CLI and Docker Engine on your local computer to complete this tutorial. You cannot use the Azure Cloud Shell for this tutorial.

Azure CLI: You must have Azure CLI version 2.0.29 or later installed on your local computer. Run az --version to find the version. If you need to install or upgrade, see Install the Azure CLI.

Get application code

The sample application in this tutorial is a simple web app built in Node.js. The application serves a static HTML page, and looks similar to the following screenshot:

Use Git to clone the sample application's repository:

Bash

git clone https://github.com/Azure-Samples/aci-helloworld.git

You can also download the ZIP archive from GitHub directly.

Build the container image

The Dockerfile in the sample application shows how the container is built. It starts from an official Node.js image based on Alpine Linux, a small distribution that is well suited for use with containers. It then copies the application files into the container, installs dependencies using the Node Package Manager, and finally, starts the application.

Dockerfile

FROM node:8.9.3-alpine
RUN mkdir -p /usr/src/app
COPY ./app/ /usr/src/app/
WORKDIR /usr/src/app
RUN npm install
CMD node /usr/src/app/index.js

Use the docker build command to create the container image and tag it as aci-tutorial-app:

Bash

docker build ./aci-helloworld -t aci-tutorial-app

Output from the docker build command is similar to the following (truncated for readability):

Console

$ docker build ./aci-helloworld -t aci-tutorial-app
Sending build context to Docker daemon  119.3kB
Step 1/6 : FROM node:8.9.3-alpine
8.9.3-alpine: Pulling from library/node
88286f41530e: Pull complete
84f3a4bf8410: Pull complete
d0d9b2214720: Pull complete
Digest: sha256:c73277ccc763752b42bb2400d1aaecb4e3d32e3a9dbedd0e49885c71bea07354
Status: Downloaded newer image for node:8.9.3-alpine
 ---> 90f5ee24bee2
...
Step 6/6 : CMD node /usr/src/app/index.js
 ---> Running in f4a1ea099eec
 ---> 6edad76d09e9
Removing intermediate container f4a1ea099eec
Successfully built 6edad76d09e9
Successfully tagged aci-tutorial-app:latest

Use the docker images command to see the built image:

Bash

docker images

Your newly built image should appear in the list:

Console

$ docker images
REPOSITORY          TAG       IMAGE ID        CREATED           SIZE
aci-tutorial-app    latest    5c745774dfa9    39 seconds ago    68.1 MB

Run the container locally

Before you deploy the container to Azure Container Instances, use docker run to run it locally and confirm that it works. The -d switch lets the container run in the background, while -p allows you to map an arbitrary port on your computer to port 80 in the container.

Bash

docker run -d -p 8080:80 aci-tutorial-app

Output from the docker run command displays the running container's ID if the command was successful:

Console

$ docker run -d -p 8080:80 aci-tutorial-app
a2e3e4435db58ab0c664ce521854c2e1a1bda88c9cf2fcff46aedf48df86cccf

Now, navigate to http://localhost:8080 in your browser to confirm that the container is running. You should see a web page similar to the following:

Create an Azure container registry and push a container image

Create Azure container registry

Before you create your container registry, you need a resource group to deploy it to. A resource group is a logical collection into which all Azure resources are deployed and managed.

Create a resource group with the az group create command. In the following example, a resource group named myResourceGroup is created in the eastus region:

Azure CLI

az group create --name myResourceGroup --location eastus

Once you've created the resource group, create an Azure container registry with the az acr create command. The container registry name must be unique within Azure, and contain 5-50 alphanumeric characters. Replace <acrName> with a unique name for your registry:

Azure CLI

az acr create --resource-group myResourceGroup --name <acrName> --sku Basic

Here's partial output for a new Azure container registry named mycontainerregistry082:

Output

{
  "creationDate": "2020-07-16T21:54:47.297875+00:00",
  "id": "/subscriptions/<Subscription ID>/resourceGroups/myResourceGroup/providers/Microsoft.ContainerRegistry/registries/mycontainerregistry082",
  "location": "eastus",
  "loginServer": "mycontainerregistry082.azurecr.io",
  "name": "mycontainerregistry082",
  "provisioningState": "Succeeded",
  "resourceGroup": "myResourceGroup",
  "sku": {
    "name": "Basic",
    "tier": "Basic"
  },
  "status": null,
  "storageAccount": null,
  "tags": {},
  "type": "Microsoft.ContainerRegistry/registries"
}

The rest of the tutorial refers to <acrName> as a placeholder for the container registry name that you chose in this step.