DEV Community: Emily Freeman

Preventing Leaked Secrets in Azure

Emily Freeman — Tue, 30 Apr 2019 15:38:05 +0000

We've selected our favorite tips and tricks created by Michael Crump and are delivering fresh technical content on Azure all April! Miss a day (or more)? Catch up with the series.

Don't have Azure? Grab a free subscription.

Preventing Leaked Secrets with .NET Core

I think almost everyone has committed a secret, key or password to git at some point in their development careers. I definitely have. And if you think you haven't, go double-check.

It sucks. And it's easy to do.

Azure's solution for secrets management is Azure Key Vault.

But what if you wanted to roll your own solution? We're engineers after all...

Rolling Your Own Secret Manager

Azure Key Vault is cheap but not completely free. And there is an overhead of learning the service. (Though I'd argue it's extremely simple.)

Secret Manager is a Microsoft solution for storing sensitive data during the development of an ASP.NET Core project.

Information is always stored in the user profile directory such as %APPDATA%\microsoft\UserSecrets\<userSecretsId>\secrets.json for Windows or ~/.microsoft/usersecrets/<userSecretsId>/secrets.json for Mac/Linux.

This means if other folks want to get your key store, they can target those directories b/c the JSON file is unencrypted. Not that my version is encrypted, it just isn’t stored in the user profile directory.

Preventing Problematic Pushes

If you work in .NET Core, you can prevent an accidental push of sensitive data to GitHub.

Step 1

Create a new .NET Core App in Visual Studio.

Step 2

Add a file called appSecrets.json and define a couple of secrets that you don’t want released.

{
  "ConnectionStrings": {
    "BitlyAPI": "A_BITLY_API_KEY",
    "StorageAccountAPI": "MY_STORAGE_ACCOUNT_KEY"
  }
}

Step 3

Set the appSecrets.json file to Copy if newer inside of Visual Studio.

Step 4

Add the following NuGet packages that allow you to easily read a local JSON file (such as your appSecrets.json) and extract key pieces of information:

Microsoft.Extensions.Configuration
Microsoft.Extensions.Configuration.FileExtensions
Microsoft.Extensions.Configuration.Json

Step 5

Add the following code inside the Main method. This uses ConfigurationBuilder and searches for the file.

var builder = new ConfigurationBuilder()
    .SetBasePath(Directory.GetCurrentDirectory())
    .AddJsonFile("appSecrets.json", optional: false, reloadOnChange: true);

IConfigurationRoot configuration = builder.Build();

You can now access the value of the string with the following:

configuration.GetConnectionString("StorageAccountAPI")

Step 6

Set your /.gitignore to ignore the appSecrets.json that you added.

## Ignore Visual Studio temporary files, build results, and
## files generated by popular Visual Studio add-ons.

appSecrets.json

You can verify this file is ignored by looking for the red circle if using Visual Studio.

Not too complicated. But! I really do recommend using Azure Key Vault as it's simple and can protect you across your entire software delivery lifecycle.

Want to read more on secrets in Azure? We've got you covered on everything keys, secrets and certificates.!

We'll be posting articles every day in April, so stay tuned or jump ahead and check out more tips and tricks now.

Creating an HTTP Request Trigger in Azure Logic Apps

Emily Freeman — Mon, 29 Apr 2019 15:49:07 +0000

Thank you to Michael Crump for creating this content!

Don't have Azure? Grab a free subscription.

Logic Apps are a service in Azure that allow you to connect various SaaS services within Azure and beyond to automate tasks. Any business process or workflow can be designed and executed.

Check out Cecil Phillip's and Michael Crump's video tutorial on setting up a logic app.

Setting up a Logic App

Go to the Azure Portal and create a new Logic App.

After the resource is ready, we’re are going to need to trigger an action when an HTTP request comes in.

Thankfully, this is one of the Common Triggers and we can select it to begin.

The URL isn’t generated until we provide the parameters.

Go ahead and press Edit and paste in a JSON schema the request should expect. Here's an example.

{
  "$schema": "http://json-schema.org/draft-06/schema#", 
  "definitions": {}, 
  "id": "http://example.com/example.json", 
  "properties": {
    "csv": {
      "id": "/properties/csv", 
      "type": "string"
    }, 
    "filename": {
      "id": "/properties/filename", 
      "type": "string"
    }, 
    "gpx": {
      "id": "/properties/gpx", 
      "type": "string"
    }, 
    "kml": {
      "id": "/properties/kml", 
      "type": "string"
    }
  }, 
  "type": "object"
}

You can use the Use sample payload to generate schema option, but I prefer the additional metadata that JSON Schema can provide.

Upload Files

We've set up an Azure Logic App to receive an HTTP Request which included a JSON payload.

Now let's integrate with OneDrive to automatically upload files.

Typically, you’ll add an Action or Condition to trigger once the HTTP request is complete.

We’ll select an Action as we want it to run every time. A Condition would use If...then logic after the HTTP request comes in.

Select Action and search for upload file to onedrive and you’ll see the following is available to use.

You’ll have to sign in to your OneDrive account.

Now you can pull the fields that we captured and use them as dynamic content.

For example, a GPX file contains a full URL, so we can just use that dynamic field. For the destination URL, we’ll construct where we want it to go in our OneDrive account.

This is just one idea You can integrate with dozens of everyday tools with [Azure Logic Apps].

Ready to set up your Logic App? Check out our stellar documentation.

We'll be posting articles every day in April, so stay tuned! Or jump ahead and check out more tips and tricks now.

Azure Search with SQL Server

Emily Freeman — Mon, 29 Apr 2019 01:14:47 +0000

Thank you to Michael Crump for creating this content!

Don't have Azure? Grab a free subscription.

Implementing Azure Search with SQL Server and ASP.NET MVC

Today's tutorial covers Azure Search and SQL Server in a ASP.NET MVC web app.

What's Azure Search?

Azure Search is a SaaS — in this case, search-as-a-service — cloud solution that allows you to access REST APIs (along with an SDK) to search over your content using web, desktop or mobile apps.

There are a variety of services to which you can attach Azure Search, including SQL Server.

Creating the Indexer

This requires creating a SQL Server Database in which we'll store the indexer.

Go into the Azure Portal.
Search for "SQL Server" and click the Add button.
Give it a database name and resource group.
Fill out the new server information.
Click on the Additional settings tab.
In "Use existing data" select "Sample". This will use AdventureWorksLT as the sample database.

Remember! Double check you selected theAdventureWorksLT database if you want to follow along with this tutorial.

AdventureWorks is an example database we've built just for you!

Taking A Peek at the Data

Now that we have a sample database and it has deployed, let’s use Query Editor inside the SQL Server blade to take a look at the table structure.

You can also use SQL Server Management Studio if you prefer it better.

If you click on Query Editor and login as instructed, then you’ll see the following:

As you can see, I expanded the Table dropdown and I can drill down again to the column names.

It looks like Customer would be a great table to implement search and we could pass in the FirstName or LastName field.

Trying writing a simple query to select the FirstName and LastName from SalesLT.Customer. Click Run to take a look at the data.

Now that we have our database in place and some solid data to work with, we’ll implement Azure Search.

Implementing Azure Search

Let's add Azure Search to our existing SQL Server instance.

Open the Azure Portal.
Navigate to your SQL Server instance and begin by looking at the Settings pane.

Select a Add Azure Search and fill out the fields specified below and make sure to select the price as free.

Under Data Source, we can easily connect to our Azure SQL Database.

Give it a name.
Provide the userid and password specified when setting up the SQL database.
Press Test Connection.
If everything goes well, then you’ll be able to select the Customer table.

Next, set an index.

Give it a name.
Select CustomerID as your key.
Clean up the fields by deleting any you don't want.
Make sure the fields can be retrieved, sorted, filtered and are searchable by adding a check like the photo below.

We need to create an indexer. I’m going to select the daily schedule and set my watermark column to the ModifiedDate as I assume data is unique in that column.

Once you kick that off, you’ll see the following notification. It states you can check the monitor progress and once complete you can start searching.

If you go ahead and click on the link on the notification window, then you’ll see the following screen.

Go ahead and press the Run button and it will start immediately. Eventually — expected time varies — you’ll see it has completed.

Excellent! Our SQL database and Azure Search indexer are in place.

Want to know more about Azure Search? Check out our quickstarts and tutorials!

We'll be posting articles every day in April, so stay tuned! Or jump ahead and check out more tips and tricks now.

Demystifying ARM Templates (Azure Resource Manager)

Emily Freeman — Sun, 07 Apr 2019 18:37:33 +0000

We've selected our favorite tips and tricks created by Michael Crump and are delivering fresh technical content on Azure all April! Miss a day (or more)? Catch up with the series.

Don't have Azure? Grab a free subscription.

If you've been in tech long enough, you might associate ARM with CPU architecture. In this case, ARM stands for Azure Resource Manager. ARM is how you organize all your stuff on Azure — virtual machines (VMs), databases, storage accounts, containers, web apps, bots and more.

In Azure, we call ALL your stuff resources.

Most people tend to create multiple related items together in Azure. A web app and a database might be contained in a single resource group. But what if you had to do this all the time? Or for many different clients?

Wouldn’t it be nice to have an easy way to keep track of all the repeatable groups of resources you are creating for people? Good news, this is exactly what ARM templates do!

Want more ARM Templates? Check out our overview!

Real Scenarios for ARM Templates

When you need an easy way to repeat infrastructure deployments on Azure, ARM templates are going to save you a lot of time.

If you ever need to share your infrastructure with other people — such as opensource projects or for blogs, tutorials and documentation — ARM templates will be a lifesaver and will let your readers and users replicate what you did.

Finally, if you just need a way to keep track of what you deployed on Azure, ARM templates are a great way to help you remember.

It's Just a JSON File

This is where ARM templates come in. ARM templates are JSON files that act like blueprints for the related resources you want to deploy together. You’ll also hear this called “infrastructure as code,” or IaC, which is geek-speak for being able to upload your infrastructure notes to GitHub if you want to.

It’s a structured format for keeping track of your Azure infrastructure with some superpowers. The biggest ARM template superpower is that you can use templates to automate your infrastructure deployments because Azure knows how to read them. After all, it's really just a JSON file.

In the example below, we are creating an ARM template that creates a Notification Hub. You'll see that it contains things that the deployment needs such as Name, Location, etc.

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "namespaceName": {
            "type": "string",
            "metadata": {
                "description": "The name of the Notification Hubs namespace."
            }
        },
        "location": {
            "type": "string",
            "defaultValue": "[resourceGroup().location]",
            "metadata": {
                "description": "The location in which the Notification Hubs resources should be deployed."
            }
        }
    },
    "variables": {
        "hubName": "MyHub"
    },
    "resources": [
        {
            "apiVersion": "2014-09-01",
            "name": "[parameters('namespaceName')]",
            "type": "Microsoft.NotificationHubs/namespaces",
            "location": "[parameters('location')]",
            "kind": "NotificationHub",
            "resources": [
                {
                    "name": "[concat(parameters('namespaceName'), '/', variables('hubName'))]",
                    "apiVersion": "2014-09-01",
                    "type": "Microsoft.NotificationHubs/namespaces/notificationHubs",
                    "location": "[parameters('location')]",
                    "dependsOn": [
                        "[parameters('namespaceName')]"
                    ]
                }
            ]
        }
    ]
}

Getting Started

You can make an ARM template in Visual Studio, in VSCode, or in the Azure portal.

The last way is probably the easiest since it walks you through the process. Start creating a resource through the portal the way you normally would, by clicking on Create Resource on your Azure Portal dashboard.

Now select what you'd like to create. I'm going to create a Web App. Look at the bottom of this page and you'll see automation options.

But what does that unassuming link labeled Automation options next to it do? You’ve probably never noticed it before or been afraid to mess with it, but if you click on that link, you will be on the road to creating an ARM template for your resource.

Taking It One Step Further

Go ahead and click Create a resource inside the Azure Portal and select Web App.

Enter a Name and a Resource Group for your web app and click Automation options at the bottom before you hit Create in order to start creating your ARM template.

After you click Automation options, you'll see something like this:

The template to create a web app (or any other Azure resource) is simply a JSON file with multiple values describing how your web app is going to be deployed. Once you overcome the fancy jargon, it's pretty simple. And we make it easy for you to get started without speaking fluent JSON.

Creating Static App Settings for your Azure App Service

To make things as easy as possible, let’s assume for now that you want to add the exact same settings every time you deploy your web app template.

Go to Deploy then Edit Template and paste the following settings fragment to overwrite your template’s resource section. (You could, of course, add as many keys as your web app needs or make changes as you see fit.)

We are adding three names and 3 values for MyFirstName, MyLastName, and MySSN.

  "resources": [
  {
    "apiVersion": "2016-03-01",
    "name": "[parameters('name')]",
    "type": "Microsoft.Web/sites",
    "properties": {
        "name": "[parameters('name')]",
        "siteConfig": {
            "appSettings": [
            {
              "name": "MyFirstName",
              "value": "Michael"
            },
            {
              "name": "MyLastName",
              "value": "Crump"
            },
            {
              "name": "MySSN",
              "value": "355-643-3356"
            }
          ]
        },
        "serverFarmId": "[concat('/subscriptions/', parameters('subscriptionId'),'/resourcegroups/', parameters('serverFarmResourceGroup'), '/providers/Microsoft.Web/serverfarms/', parameters('hostingPlanName'))]",
        "hostingEnvironment": "[parameters('hostingEnvironment')]"
    },
    "location": "[parameters('location')]"
  }],

Press Save. Ensure the settings are filled out. Agree to the terms and check the Purchase option.

If it says failure to deploy, then give it a shot again. Sometimes an asynchronous return is the only hiccup.

Your settings (for MyFirstName, MyLastName, and MySSN) will now be deployed.

After deployment, navigate to your App Service and go to Application Settings. You'll see your site deployed along with the settings that we specified earlier.

Now let's look at adding parameters.

Inputting Values Before Deployment

You’ve already seen that you can automate deploying static configuration information like app settings with your ARM template. But what about providing parameters that allow end-users to input values BEFORE deployment.

Go ahead and search for templates inside the Azure Portal and click Add to create a new one.

Enter a name and a description on the ARM Template.

Choose Your Own Adventure

We want to have dynamic settings that are customizable every time you deploy your web app instead of having them be the same each time, you just need to add the parameter values for what you want to your ARM template.

Below is a sample of three values (FirstNameValue, LastNameValue and SSNValue) that we previously hardcoded before:

"FirstNameValue": {
    "type": "string"
},
"LastNameValue": {
    "type": "string"
},
"SSNValue": {
    "type": "string"
},

We'll add the same parameters called FirstNameValue, LastNameValue and SSNValue to the parameters collection of the template. From now on, every time you deploy this template, you will be prompted to enter a value for each one.

"siteConfig": {
    "appSettings": [
        {
            "name": "MyFirstName",
            "value": "[parameters('FirstNameValue')]"
        },
        {
            "name": "MyLastName",
            "value": "[parameters('LastNameValue')]"
        },
        {
            "name": "MySSN",
            "value": "[parameters('SSNValue')]"
        }
    ]
}

Stringing Everything Together

Our full template file looks like the following:

{
    "$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentTemplate.json#",
    "contentVersion": "1.0.0.0",
    "parameters": {
        "appServiceName": {
            "type": "string",
            "minLength": 1,
            "maxLength": 10
        },
        "appServicePlanName": {
            "type": "string",
            "minLength": 1
        },
        "FirstNameValue": {
                "type": "string"
            },
            "LastNameValue": {
                "type": "string"
            },
            "SSNValue": {
                "type": "string"
            },
        "appServicePlanSkuName": {
            "type": "string",
            "defaultValue": "S1",
            "allowedValues": [
                "F1",
                "D1",
                "B1",
                "B2",
                "B3",
                "S1",
                "S2",
                "S3",
                "P1",
                "P2",
                "P3",
                "P4"
            ],
            "metadata": {
                "description": "Describes plan's pricing tier and capacity. Check details at https://azure.microsoft.com/en-us/pricing/details/app-service/"
            }
        }
    },
    "variables": {
        "appHostingPlanNameVar": "[concat(parameters('appServicePlanName'),'-apps')]"
    },
    "resources": [
        {
            "name": "[variables('appHostingPlanNameVar')]",
            "type": "Microsoft.Web/serverfarms",
            "location": "[resourceGroup().location]",
            "apiVersion": "2015-08-01",
            "sku": {
                "name": "[parameters('appServicePlanSkuName')]"
            },
            "dependsOn": [],
            "tags": {
                "displayName": "appServicePlan"
            },
            "properties": {
                "name": "[variables('appHostingPlanNameVar')]",
                "numberOfWorkers": 1
            }
        },
        {
            "name": "[parameters('appServiceName')]",
            "type": "Microsoft.Web/sites",
            "location": "[resourceGroup().location]",
            "apiVersion": "2015-08-01",
            "dependsOn": [
                "[resourceId('Microsoft.Web/serverfarms', variables('appHostingPlanNameVar'))]"
            ],
            "tags": {
                "[concat('hidden-related:', resourceId('Microsoft.Web/serverfarms', variables('appHostingPlanNameVar')))]": "Resource",
                "displayName": "webApp"
            },
            "properties": {
                "name": "[parameters('appServiceName')]",
                "serverFarmId": "[resourceId('Microsoft.Web/serverfarms', variables('appHostingPlanNameVar'))]",
                "siteConfig": {
                    "appSettings": [
                        {
                            "name": "MyFirstName",
                            "value": "[parameters('FirstNameValue')]"
                        },
                        {
                            "name": "MyLastName",
                            "value": "[parameters('LastNameValue')]"
                        },
                        {
                            "name": "MySSN",
                            "value": "[parameters('SSNValue')]"
                        }
                    ]
                }
            }
        }
    ],
    "outputs": {}
}

If you save the template, then the next time you deploy resources using this ARM template, you will be required to put in a new value for the first name, last name, and SSN that will be used in your application settings.

And after deployment, go and check your App Settings.

Pretty cool, huh? Once I overcame the confusion of what ARM templates are and why I need them, it's like my brain opened up. ARM templates make your life easier by automating resource management and customizing values as needed.

Want to learn more about ARM Templates? Check out our overview!

We'll be posting articles every day in April, so stay tuned or jump ahead and check out more tips and tricks now.

Working with Storage Blobs

Emily Freeman — Sat, 06 Apr 2019 15:45:06 +0000

We've selected our favorite tips and tricks created by Michael Crump and are delivering fresh technical content on Azure all April! Miss a day (or more)? Catch up with the series.

Don't have Azure? Grab a free subscription.

Azure Storage is described as a service which provides storage that is available, secure, durable, scalable, and redundant.

Azure Storage is an umbrella term. It covers:

We're going to focus on Blob storage for now.

Creating Blob Storage in the Azure Portal 📂

Go ahead and open the Azure Portal and click Create a Resource. Select Azure Storage. We’ll keep it simple as shown below to get started.

Once complete — the portal will notify you — go into the resource and look under Services.

Go ahead and click on Blobs and create a Container and give it the name Images.

Remember! A container is a lot like a folder. https://myblob/container/image1.jpg

You’ll now want to click Upload and select a file on your physical disk.

Now that your file is uploaded, select it. You can click on the ellipsis and select Blob properties to see additional details.

Yay! You can download it or access it via the URL provided. That was pretty easy, right?

Let's do the same thing... differently.

Provisioning an Azure Storage Blob Container in C# 🗄️

Yes, the code we're using is C# but don't freak out if you don't know C# (I don't!) Michael Crump wrote this code and I think it's clear what's happening — regardless of your language of choice.

Navigate to your Azure Storage account in the portal.

Look under Settings, then Access Keys and copy the connection string.

Create a C# Console Application, and use NuGet to pull in references to:

WindowsAzure.Storage
Microsoft.WindowsAzure.ConfigurationManager

Inside of your Console app, you will see App.config, now add the following section:

<appSettings>
  <add key="StorageConnection" value="YOUR-CONNECTION-STRING-COPIED-FROM-EARLIER"/>
</appSettings>

Copy the following code into your Main method:

static void Main(string[] args)
{
    var storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnection"));
    var myClient = storageAccount.CreateCloudBlobClient();
    var container = myClient.GetContainerReference("images-backup");

container.CreateIfNotExists(BlobContainerPublicAccessType.Blob);
    Console.ReadLine();
}

This code will get our connection string from the App.config, create our client and a container named images-backup if it doesn’t exist. We can go back inside of the portal to see if executed correctly.

Success! We’ve now accomplished the same task via the Azure Portal and C#.

Want more Azure Storage? Check out our quickstarts and tutorials!

We'll be posting articles every day in April, so stay tuned or jump ahead and check out more tips and tricks now.

Setting Up SQL Server and Connecting Visual Studio with Swagger

Emily Freeman — Fri, 05 Apr 2019 13:32:52 +0000

We've selected our favorite tips and tricks created by Michael Crump and are delivering fresh technical content on Azure all April! Miss a day (or more)? Catch up with the series.

Don't have Azure? Grab a free subscription.

If you haven't had a chance to dig into Azure DevOps yet, I think you're missing out. It's incredibly powerful and has a truly enjoyable user experience. (And I was pretty skeptical when I started using it.)

This example doesn't necessarily cover the exact stack you're using. But it does provide an end-to-end example of how to string different products together from within the Azure ecosystem and make your software delivery more continuous.

Crystal Tenn and Michael Crump from Azure Tips and Tricks teamed up to feature an Azure App Service site that communicates with an API project and an Azure SQL backend.

The app is a basic To-Do application — we'll call it TODO — created with Visual Studio, VSTS (now Azure DevOps), C#, Angular, and SQL.

You're welcome to follow along with the tutorial or simply read and get a better idea of how you can apply the same patterns to your app.

The Process 🗒️

The process for the app is described below. In Visual Studio, you will start out with a working version of the TODO application. You will push the code to Azure DevOps and create a CI/CD (Continuous Integration/Continuous Delivery) process in order to deploy to Azure.

In Azure you will create 3 resources:

Azure Web App
Azure API App
Azure SQL Server

Prerequisites 📇

Please download the required software listed below. The tutorial can be completed for free, but will require a Azure account. You will need a basic understanding of coding and software installation.

The Azure account asks you for a credit card number, but will not charge you at all or “roll into a paid version,” it simply expires when your trial month is up.

Get a Free Azure Account

You get $200 USD credit a month, these are free credits on a trial account and cost you nothing.

Download Visual Studio 2017

As a note, the instructions will be using Visual Studio 2017. You can get Visual Studio 2017 Community for free here.

Snag SQL Server Express

You can grab the Express edition here.

Don't Forget SQL Server Management Studio

You can find what you need here.

Setting Up SQL Server Locally 💾

The local setup will start with setting up your database. You will then open the solution in Visual Studio. You need to connect the API project to your SQL Server. Then connect your frontend Angular project to the API project.

We’ll be working with an existing app. Download a copy here and extract it to a folder on your hard drive.

Let's get started!

Step 1

Open SQL Server Management Studio (SSMS) and click the dropdown on Server Name and choose Browse for more.

Step 2

Choose the Server name of your instance. This name most likely will be in the format ComputerName\ServerName.

Step 3

Choose Windows Authentication. Save your ComputerName\ServerName in a Notepad, we will need this again later. Hit Connect.

Step 4

Open the folder that we downloaded earlier by double clicking ToDoList.sln. It should open in Visual Studio 2017.

Step 5

Right click on the ToDoListDb project and choose Publish.

Step 6

On the modal, click Edit.

Step 7

For Server name, take the Notepad value you saved for ComputerName\ServerName and enter it here. Make sure the Database Name is ToDoListDb, but that should be filled in for you. Click OK.

Step 8

Don’t edit any other values on this modal and just hit Publish. Note: Test Connection will not work.

Step 9

You will see the publish begin.

Step 10

It is done when you see this:

Step 11

Go back to SQL Server Management Studio and hit refresh.

Step 12

Your SQL database should look something like this now.

Connecting Visual Studio and SQL Database 💽

Now we need to link up all the pieces to ensure data is gathered and stored correctly.

Step 1

Open the project in Visual Studio by double clicking ToDoList.sln, if it is not already open from Part 1.

Step 2

Open the Web.config file of the ToDoListDataAPI project. Make sure you are in the right project.

Step 3

Edit the ComputerName\ServerName highlighted and change it to your computer & SQL server name that you saved in a Notepad.

Mine looks like:

Your inputs and outputs will vary slightly based on your unique resource naming and credentials.



<add name="todoItems" connectionString="Server=MICHAELCRUM0FD9\SQLEXPRESS;Initial Catalog=todolistdb;MultipleActiveResultSets=False;Integrated Security=True" providerName="System.Data.EntityClient" />

Step 4

Save the file and set the ToDoListDataAPI project to Set as Startup project by right clicking on the project and choosing that option.

Hit F5 or run inside any browser.

If you get The Web server is configured to not list the contents of this directory, then just proceed to step 6.

Step 5

Add /swagger to the URL if it is not already there for you. The page should look like this if everything is working properly:

Step 6

Click Show/Hide to get a full list of APIs available to the application.

Step 7

Click on GET (the first one in the list) to expand it. Click Try it out!.

If you get a 200 Response Code, it worked! Also take note of the URL port number in your browser.

Step 8

Switch back over to Visual Studio and go to the Web.config in the ToDoListAngular project.

Step 9

Make sure that the port number matches the port from the last step.

Step 10

Set the ToDoListAngular project as Startup Project.

Step 11

Hit F5 or run. You should see the Angular app running in your web browser.

Click on TODO list menu and add an entry. Try editing it and deleting it. You can put breakpoints in the code to learn more about how it is performing the CRUD operations. You can also check the SQL database to see the entries.

Congrats! We now have our SQL database and web front/backend setup locally. Next, we’ll look deeper into Swagger and deploying with Azure App Service.

Local Setup + Working with Swagger 📔

What is Swagger UI? is a collection of HTML, Javascript, and CSS assets that dynamically generate beautiful documentation from a Swagger-compliant API.

The nice thing about Swagger is that you can create an existing Web API app using the VS Templates and add Swagger via Nuget.

Then if you spin up a project, you simply add /swagger to see the UI. In the example below, we’ve already added it and supplied the comments in the app to where it recognizes it. This makes testing APIs very simply and it works in real-time, meaning if you run a POST, then you can immediately check your database for the new record.

Learn more about Swagger here.

Let's get going!

Swagger All The Things 📖

Step 1

Open the project in Visual Studio by double clicking ToDoList.sln, if it is not already open from the previous parts. Navigate to the ToDoListDataAPI project.

Step 2

Set the ToDoListDataAPI project to Set as Startup project by right clicking on the project and choosing that option and run the application.

Step 3

Add /swagger to the end of your URL if it is not already there, you should see a page like this:

Step 4

Click on the Show/Hide button.

Step 5

Run a GET which is the first API on the page /api/ToDoList, you should see:

Step 6

Run a POST, click where the screenshot shows, and fill in an ID with a random number and any description you want and then click Try it out!.

Step 7

Run a GET again, you should see your added value:

Step 8

Run a PUT, again click to get the format from where it’s shown in the screenshot and modify an existing record’s description.

Step 9

Try to run a GET by ID, use 1 for example:

Step 10

Switch back to SQL Server Management Studio (and log in if you need to) and choose Select Top 1000 Rows on the ToDoListDb db to see the data.

Step 11

Your SQL Server Management Studio table should look like this now:

Next we need to deploy the SQL database.

Ready to dig into Azure DevOps and see how we've evolved the product from VSTS? Check out our Azure DevOps quickstarts and tutorials!

Deploy SQL Database to Azure SQL 📬

Step 1

Log into the Azure Portal at portal.azure.com if you aren’t already logged in.

Step 2

Create a new SQL Database. Click New, select Databases, choose SQL Database, then lastly hit Create.

Step 3

Click on Server and Pricing Tier to get a slideout options. In the Server slideout, make sure you create a username and password and keep it somewhere safe as you will need this to login using SQL Server Management Studio (SSMS). In the Pricing Tier, change to Basic so it only costs about $5 per month. Your screen will look approximately like this:

Step 4

Click on All Resources on the left menu. You should see your new SQL Server and SQL Database. Click on the SQL Database.

Step 5

On the Overview tab. Copy the Server name to somewhere safe. Click on the Show Connection Strings and copy it somewhere safe.

The connection string will look like this (save this in a Notepad for the web.config in the solution later):

Step 6

Open SSMS and enter the server name, username, and password as shown below.

If you cannot login, please go to the Portal and add your IP address by clicking on the SQL Server you created, then going to Firewall. You may also be able to set the firewall prompt through the SQL Server tool.

Step 7

Go back to the Part 1 and repeat steps 6-13, except use the Azure SQL Server name that we created earlier instead of your local DB.

Step 8

Once the DB has been saved to Azure, go into the connection strings of your API project that can be found in the web.config as shown below.

Step 9

In the web.config, change your connection string so that it points to your Azure SQL Server connection string (that you should have saved into Notepad earlier). Make sure you add your username and password for your Azure SQL Server into the connection string.

Frontend Angular + Backend API projects 🖥️

Before we begin, I’m assuming you’re using the same email address for Azure DevOps that you are using for Azure.

Step 1

Open the solution file in Visual Studio, if it is not already opened. Login to Visual Studio with the same email address that you used to signup for your Azure account.

Step 2

Right click on the API project and choose Publish.

Step 3

Choose an App Service.

Step 4

Fill in all the settings: add in a name, choose the subscription, create a new resource group. For the App Service Plan: choose a name, the closest location to you and Free. Then on the main modal click Create.

If you are on the ToDoListAPI project, make sure you have API selected.

If you are on the ToDoListAngular project, make sure you have Web App selected.

Step 5

Make sure it shows up in the Azure Portal after giving it a few minutes to publish. Click on the API project to go to the overview (red arrow).

Step 6

Copy the URL of the API App Service as highlighted in the screenshot.

Step 7

Let’s connect the frontend to the API project. Open up the ToDoListAngular solution. Go to the web.config file of your frontend ToDoListAngular project. Paste in the URL from the previous step.

Step 8

Let’s do the same publishing to Azure for the frontend project.

Repeat steps 2-5, BUT do it on the frontend ToDoListAngular project. Make sure on Step 4 you choose the right option of Web App for the Angular Web project.

Step 9

Verify once you are done publishing that it is in the Azure Portal. Click on the App Service (red arrow in screenshot).

Step 10

On the Overview page, copy the URL.

Step 11

Paste the URL into your browser and click on the Todo tab to see the Todo list. You should now have a working Azure App Service Web front end talking to an Azure App Service API which connects to Azure SQL.

Great, so now you’ve moved your project to the cloud with Azure!

Ready to dig into Azure DevOps and see how we've evolved the product from VSTS? Check out our Azure DevOps quickstarts and tutorials!

We'll be posting articles every day in April, so stay tuned or jump ahead and check out more tips and tricks now.

Deploy Jekyll Site Hosted on GitHub to Azure

Emily Freeman — Thu, 04 Apr 2019 02:56:26 +0000

We've selected our favorite tips and tricks created by Michael Crump and are delivering fresh technical content on Azure all April! Miss a day (Or more)? Catch up with the series.

Don't have Azure? Grab a free subscription.

A ton of us use Jekyll for our personal sites and/or blogs.

If you have already have an existing Jekyll based site that is hosted on GitHub, you can easily deploy that site to Azure App Services.

But why? If GitHub Pages is free, then why pay? You might want to:

push your site to a private repo (instead of public).
set up “real” SSL, compared to the workarounds.
take advantage of deployment slots.

I’m sure there are more. Regardless, I think it's an interesting exercise using an incredibly common tool.

Gather All The Pieces 📎

I’m assuming you already have a GitHub Pages site that uses Jekyll hosted on GitHub. If that is true, then the first thing that you’ll want to do is grab these three files.

deploy.cmd: a Kudu Deployment script that handles setup and deployment of the web site and ensures Ruby is installed
getruby.cmd: a site that ensure the latest version of Ruby is installed and ensures Jekyll has been built
.deployment: a configuration file that Kudu understands that calls the deploy.cmd script
Gemfile: you probably already have this but ensure it is there and if not then just copy mine.

Once you have these three files, ensure they are in the root of your public GitHub pages site (e.g. something.github.io).

Travel To The Azure Portal 🖱️

You’ll want to go inside of your Azure Portal (or use the CLI tools) and create a Web App under App Service. Once the site is deployed, then go to Deployment Options and select GitHub, your project and press OK.

You should see Setup up Deployment Source… in the notification window. You’ll probably want to wait a good 15 to 20 minutes for Azure to setup everything. You can stay on the Deployment Options blade and you should see the status of the deployment.

Success! ✅

After a while you see a check mark that it completed successfully. Now you can navigate to the URL listed on the Overview blade.

And... you're done! Check it out. That was easy, right?!

Ready to go beyond Jekyll? Check out Azure's App Service documentation for language-specific quickstarts.

We'll be posting articles every day in April, so stay tuned! Or jump ahead and check out more tips and tricks now.

Node.js + AKS on Azure DevOps

Emily Freeman — Wed, 03 Apr 2019 00:35:05 +0000

We've selected our favorite tips and tricks created by Michael Crump and are delivering fresh technical content on Azure all April! Miss a day (or more)? Catch up with the series.

Don't have Azure? Grab a free subscription.

I want to give you a quick tour around Azure DevOps and Azure Kubernetes Service(AKS) using Node.js.

We'll walk through creating an AKS cluster using an Azure DevOps and take a look under the hood to help understand how to get started with AKS.

The Azure Portal and Azure DevOps is always evolving and improving! If a screenshot doesn't match exactly what you're seeing, that's why. I believe the explanations are enough to help you find your way. If you run into issues, comment below and we can figure it out together!

What The Heck Is Azure DevOps? And AKS?! 😅

Azure DevOps is a cloud service (formally called VSTS) for collaborating on code development. It essentially powers the entire software delivery lifecycle for engineering teams. You can create processes for you and your team around:

Source control
CD/CD
Agile tooling
Testing
Builds
Releases

You can think of Azure DevOps as a more verbose cousin to Jenkins or CircleCI.

Don't wait! Check out Azure DevOps and see how powerful it is.

Azure Kubernetes Service (AKS) manages your hosted Kubernetes environment, making it quick and easy to deploy and manage containerized applications without container orchestration expertise. It also eliminates the burden of ongoing operations and maintenance by provisioning, upgrading, and scaling resources on demand, without taking your applications offline.

Kubernetes is HOT. We've got you covered on everything you need to know.

Create Your DevOps Project 👩🏾‍💻

A common pitfall in this tutorial is creating the project before your organization has been created in Azure. If you run into any errors, ensure your organization was created in Azure.

Open the Azure portal.
Search for "DevOps" and choose DevOps Project.
Click the Add button.
Select the Node.js application, click it and then the Next button.
Select Express.js for the application framework and click Next.
For deploying the application, select Kubernetes Service and click Next.
Now just give the DevOps project an organization name and a project name. You can make this anything you want.

Provide a subscription and a cluster name and click the Done button.

Boom! You did it. Seriously. It's that easy.

A lot of amazing work is happening in the background, so now is the time to drink a cup of coffee or read another post (or drink some wine...) before clicking the refresh button on your DevOps Projects list.

Click on your DevOps project name in the list to go to the DevOps project dashboard. This has everything you need to access the source code repository and the application build and release pipelines. These pipelines automate the steps needed to take your committed code, integrate it, build it and deploy it to a live Kubernetes environment.

There are also links to your live deployed application, the Kubernetes cluster and Application Insights (telemetry for your live site).

You should also have received an email from Azure DevOps or an alert in the portal letting you know the project is ready. If you'd like, set up team members in your project.

Taking A Peek At The Code 🔍

In the CI/CD pipeline, click on the commit to see the code. You can also click on Master to take you to the full file list.

This takes you to the commit for the repo we just released containing the deployed sample app.

When you created the DevOps project, it cloned the source code from the devops-project-samples GitHub project and added it your DevOps projects and did a lot of the initial plumbing for you. How cool is that?

Taking A Look At The Build 🤓

Back on the DevOps Project dashboard, click the Build link that has the successful build number.

This takes you to the new Azure DevOps Pipelines build that was created for the project. Now click the Edit button at the top.

You now see the steps created for building a container image and a Helm package. Helm is used to deploy applications to Kubernetes and is the default in DevOps projects that target Kubernetes.

Microsoft is solving really hard problems to make your life easier.

Clicking on either of the Docker tasks will show you the new Azure Container Registry (ACR) that the DevOps project created, along with the image name, plus the build number.

The build creates an ACR as well as builds and pushes the image using Docker. It automatically checks if Helm is properly installed and begins packaging and deploying the charts/sampleapp directory. It also creates the ARM templates and finally publishes the build artifact.

If you switch back over to Repos, then Files, then Applications, you can see the charts/sampleapp folder.

We'll finish up the pipeline section by looking at dev and reviewing the resources section.

Finishing Up Your Pipelines 🔧

Back on the DevOps Project dashboard, click the Release link with the number.

Be sure the build you select is GREEN. It signifies a successful build without errors.

If the build is RED, click on it and find the error. A common error you might encounter is The subscription is not registered to use namespace 'Microsoft.ContainerService'

One way to quickly resolve that is by bringing up Cloud Shell, selecting PowerShell and running the following command:

While this is designed for PowerShell, if you're an avid Bash user, will you comment below with the command you used?



PS Azure:\> Register-AzureRmResourceProvider -ProviderNamespace “Microsoft.ContainerService”

You'll receive an output similar to below.



ProviderNamespace : Microsoft.ContainerService
RegistrationState : Registering
ResourceTypes     : {containerServices, managedClusters, locations, locations/operationresults...}
Locations         : {Japan East, Central US, East US 2, Japan West...}

If all goes well, you'll see the basic Azure DevOps release pipeline. Click the Edit release button at the top.

Then click the Edit tasks link.

You now see the list of tasks that need to be run such as Creating the AKS cluster, running a PowerShell script and packaging and deploying Helm charts.

Azure Resources In A Nutshell 🥜

Back in the DevOps Project dashboard, let’s look at the Azure resources and Application Insights. The resources are the URL to your live site running in Kubernetes and a link to the AKS cluster. The last link will take you to see the live telemetry for your site provided by Application Insights.

Telemetry is just a fancy way of saying this is how you monitor the health of your app.

Live App

Click on the External Endpoint link to be taken to the deployed application.

AKS

The second link is to the Azure Kubernetes Service.

Application Insights

The last link shows the Application Insights created for the service which includes powerful analytics tools to help you diagnose issues and to understand what users actually do with your app. It's designed to help you continuously improve performance and usability and works seamlessly with Azure DevOps

Now if you go to Resource Groups on the Azure portal and search for the name of the DevOps project, you’ll see that three resource groups were created.

Remember! Avoid any costs related to this tutorial by deleting the resources created.

Want more? Don't wait. Continue learning about Azure DevOps.

We'll be posting articles every day in April, so stay tuned! Or jump ahead and check out more tips and tricks now.

Machine Learning in Azure

Emily Freeman — Tue, 02 Apr 2019 13:05:14 +0000

We've selected our favorite tips and tricks created by Michael Crump and are delivering fresh technical content on Azure all April! Miss a day (Or more)? Catch up with the series.

Thank you also to Luis Quintanilla for inspiring this with his work on ML.NET and Azure Functions.

Don't have Azure? Grab a free subscription.

Machine learning can be tricky. Even the name stresses me out. Like... how am I supposed to TEACH a MACHINE?!

Fortunately, Azure is coming up with ways to make it easier for developers to jump into machine learning. ML.NET is the machine learning framework that Microsoft Research made just for .NET developers so you can do everything inside Visual Studio.

When you're ready to deploy your ML.NET algorithm, you can use serverless architecture through Azure Functions. You can think of it as the “Don’t worry about it!” option when you want to get an app up and running but don’t necessarily want to mess around with servers and containers and infrastructure.

Check out more ML quickstarts and tutorials!

Serverless Machine Learning

This is inspired by Luis Quintanilla’s article about using ML.NET with Azure Functions, where he took these two great ideas and combined them.

As you follow this tutorial, you will use ML.NET locally to train your machine learning model. Then you will create an Azure environment with a storage account and an Azure Function to host your machine learning app. The final step is building an app that uses your model.

Let's get started!

Create Your Model

For the ML.NET portion of this quick project, let’s build the iris categorization model from the Getting started in 10 minutes ML.NET tutorial. As a prerequisite, you’ll want to install Azure CLI 2.0, Azure Functions Core Tools and a recent version of .NET Core.

Open a command prompt and create a new folder for your ML.NET project.

> mkdir demo
> cd demo

Next, create a new solution as well as a new console project and install the ML.NET package.

> dotnet new solution
> dotnet new console -o model
> dotnet sln add model/model.csproj
> cd model
> dotnet add package Microsoft.ML --version 0.4.0
> dotnet restore

Create a data directory under model.

> mkdir data

Open the UCI Machine Learning Repository: Iris Data Set, copy and paste the data into VS Code, or TextEdit or Notepad, and save it as iris-data.txt in the data directory.

Now it’s time to write some code. Open up your project in Visual Studio Code and create a couple of data structure classes: IrisData.cs and IrisPrediction.cs.

using Microsoft.ML.Runtime.Api;

        public class IrisData
        {
            [Column("0")]
            public float SepalLength;

            [Column("1")]
            public float SepalWidth;

            [Column("2")]
            public float PetalLength;

            [Column("3")]
            public float PetalWidth;

            [Column("4")]
            [ColumnName("Label")]
            public string Label;
        }

        public class IrisPrediction
        {
            [ColumnName("PredictedLabel")]
            public string PredictedLabels;
        }

Add a model class to perform the machine learning training.

using System.Threading.Tasks;
using Microsoft.ML;
using Microsoft.ML.Data;
using Microsoft.ML.Trainers;
using Microsoft.ML.Transforms;

    class Model
    {
        public static async Task<PredictionModel<IrisData, IrisPrediction>> Train(LearningPipeline pipeline, string dataPath, string modelPath)
        {
            // Load Data
            pipeline.Add(new TextLoader(dataPath).CreateFrom<IrisData>(separator: ','));

            // Transform Data
            // Assign numeric values to text in the "Label" column, because
            // only numbers can be processed during model training
            pipeline.Add(new Dictionarizer("Label"));

            // Vectorize Features
            pipeline.Add(new ColumnConcatenator("Features", "SepalLength", "SepalWidth", "PetalLength", "PetalWidth"));

            // Add Learner
            pipeline.Add(new StochasticDualCoordinateAscentClassifier());

            // Convert Label back to text
            pipeline.Add(new PredictedLabelColumnOriginalValueConverter() { PredictedLabelColumn = "PredictedLabel" });

            // Train Model
            var model = pipeline.Train<IrisData, IrisPrediction>();

            // Persist Model
            await model.WriteAsync(modelPath);

            return model;
        }
    }

Place your logic inside the Program.cs file to run through the process:

    class Program
    {
        static void Main(string[] args)
        {
            string dataPath = "/Users/mbcrump/Documents/demo/model/data/iris-data.txt";

            string modelPath = "/Users/mbcrump/Documents/demo/model/model.zip";

            var model = Model.Train(new LearningPipeline(), dataPath, modelPath).Result;

            // Test data for prediction
            var prediction = model.Predict(new IrisData()
            {
                SepalLength = 3.3f,
                SepalWidth = 1.6f,
                PetalLength = 0.2f,
                PetalWidth = 5.1f
            });

            Console.WriteLine($"Predicted flower type is: {prediction.PredictedLabels}");

        }
    }

Run the model project to create a new model.zip file in your root directory. Below is the results that I got.

Michaels-MacBook-Pro:model mbcrump$ dotnet run
Automatically adding a MinMax normalization transform, use 'norm=Warn' or 'norm=No' to turn this behavior off.
Using 4 threads to train.
Automatically choosing a check frequency of 4.
Auto-tuning parameters: maxIterations = 9996.
Auto-tuning parameters: L2 = 2.668802E-05.
Auto-tuning parameters: L1Threshold (L1/L2) = 0.
Using best model from iteration 500.
Not training a calibrator because it is not needed.
Predicted flower type is: Iris-virginica

Congratulations! You’ve trained a machine learning model with ML.NET that categorizes irises.

Check out more ML quickstarts and tutorials!

Setting up Your Azure Environment Using Cloud Shell

We'll use Azure Cloud Shell which uses the Azure CLI to set up our Azure environment. The easiest way to do this is to sign in to your Azure portal account and click on the cloud shell icon shown below to open a bash shell or go to shell.azure.com.

Once logged in, create a new resource group for this project in the bash shell (and replace mlnetdemo as well as the location with one of your own).

$ az group create --name mlnetdemo --location westus

Add storage to this resource group.

NOTE: You'll have to change the name below to something unique

$ az storage account create --name mlnetdemostorage --location westus --resource-group mlnetdemo --sku Standard_LRS

Create your Azure Function and configure it to use the beta runtime which supports .NET Core.

NOTE: You'll have to change the name below to something unique.

$ az functionapp create --name mlnetdemoazfunction1 --storage-account mlnetdemostorage1 --consumption-plan-location westus --resource-group mlnetdemo
$ az functionapp config appsettings set --name mlnetdemoazfunction1 --resource-group mlnetdemo --settings FUNCTIONS_EXTENSION_VERSION=beta

Deploying Your Machine Learning Model

To get your model up to the server, you will need to get the keys to your storage account. Use the following command in the bash window to get it.

$ az storage account keys list --account-name mlnetdemostorage1 --resource-group mlnetdemo

You'll see the following:

[
  {
    "keyName": "key1",
    "permissions": "Full",
    "value": "YOURKEY"
  },
  {
    "keyName": "key2",
    "permissions": "Full",
    "value": "NONEYOBUSINESS"
  }
]

Use the following command to create a new directory called models to put your model in using your account key (this can be found in the navigation window under Settings | Access keys).

$ az storage container create --name models --account-key YOURKEY --account-name mlnetdemostorage1

Since we are using Cloud Shell, it will be easier to use the Azure Portal for this step. You can also use the Azure CLI if you wish.

Browse to your version of the mlnetdemo resource group and drill down to your storage resource that you created earlier. Go into the blobs and you see the new folder models subdirectory.

Upload the model.zip here which can be found on your hard drive.

Identify Irises Like a Robot

Note: Make sure you have the Azure Workload installed to see this template.

Create a new project using the Azure Functions project template called serverless_ai.

When prompted, select the Http trigger option and connect it to your Azure storage account for the project (mlnetdemostorage1 for this post).

Then complete the following steps:

Use NuGet to add the Microsoft.ML package to your project.
Copy the IrisData.cs and IrisPrediction.cs files from your model project to the serverless_ai project.

You’ll need them both again.

Change the name of the Http trigger class Function1 to Predict and copy in the following code:

using Newtonsoft.Json;
using Microsoft.ML;

namespace serverless_ai
{
    public static class Predict
    {
        [FunctionName("Predict")]
        public static IActionResult Run([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)]HttpRequest req,
        [Blob("models/model.zip", FileAccess.Read, Connection = "AzureWebJobsStorage")] Stream serializedModel,
        TraceWriter log)
        {
            if (typeof(Microsoft.ML.Runtime.Data.LoadTransform) == null ||
                typeof(Microsoft.ML.Runtime.Learners.LinearClassificationTrainer) == null ||
                typeof(Microsoft.ML.Runtime.Internal.CpuMath.SseUtils) == null ||
                typeof(Microsoft.ML.Runtime.FastTree.FastTree) == null)
            {
                log.Error("Error loading ML.NET");
                return new StatusCodeResult(500);
            }

            //Read incoming request body
            string requestBody = new StreamReader(req.Body).ReadToEnd();

            log.Info(requestBody);

            //Bind request body to IrisData object
            IrisData data = JsonConvert.DeserializeObject<IrisData>(requestBody);

            //Load prediction model
            var model = PredictionModel.ReadAsync<IrisData, IrisPrediction>(serializedModel).Result;

            //Make prediction
            IrisPrediction prediction = model.Predict(data);

            //Return prediction
            return (IActionResult)new OkObjectResult(prediction.PredictedLabels);
        }
    }
}

These lines use your model to evaluate new iris data to make a prediction. Your app is ready for testing.

Test Locally Before Deploying

To test the Azure Function app on your local machine, check your local.settings.json file to make sure that AzureWebJobsStorage has a value associated with it.

This is how your local app will find your uploaded model on your Azure storage account. If this has a value (and it should if you bound the project to your account when you created it), you can just F5 the serverless_ai project in order to run it.

Now open up Postman (or a similar REST API tool) and send a POST call to

http://localhost:7071/api/Predict with the following body:

{
 "SepalLength": 3.3,
 "SepalWidth": 1.6,
 "PetalLength": 0.2,
 "PetalWidth": 5.1
}

If all is well, the categorizer will return Iris-verginica.

To Deploy Skynet

… or whatever AI you are deploying from Visual Studio, go to your build settings in the toolbar.

Select Publish serverless_ai to deploy your Azure Function app.

To test the app deployment in the Azure Portal, select you Azure Function app under mlnetdemo (or however you named it) and then pick the Predict function under that. Use the Test panel to the right of the screen to see your deployed app in action.

This will place your iris categorizer out on Azure for other people to try. Congratulations! You are now able to deploy artificial intelligences to the cloud.

Want more machine learning on Azure? Check out our ML quickstarts and tutorials!

We'll be posting articles every day in April, so stay tuned or jump ahead and check out more tips and tricks now.

Deploying an App with the Azure CLI

Emily Freeman — Mon, 01 Apr 2019 13:47:15 +0000

Welcome to Azure April! Every day during the month of April, we'll be releasing an article on, well, Azure. The topics range but will cover:

Deploying to Azure
Blob Storage
Logic Apps
Machine Learning
Azure DevOps
ARM templates
Azure Functions
VS Code
Cosmos DB
IoT

And so much more. I'm glad you're here! I want to give a special shout out to Michael Crump for creating all the tips and tricks we've selected to highlight in Azure April.

For the first day, I've decided to kick us off with something relatively simple but important. And common! Deploying an app to Azure using only the CLI. This is one of the first things I learned when I started diving into Azure and I think builds the foundation of your Azure knowledge.

Thanks for joining us! You can always find me on Twitter.

For more information on the Azure CLI, start here.

While I love working with the Azure Portal or even Visual Studio, it is sometimes nice to do everything from the command line. In this tutorial, we'll be using a Linux VM and BASH to do everything.

Don't have Azure? Grab a free subscription.

Step 1

Ensure you have the following stack installed.

mbcrump@crumplinux:~$ git --version
git version 2.7.4
mbcrump@crumplinux:~$ nodejs --version
v4.2.6
mbcrump@crumplinux:~$ npm --version
3.5.2
mbcrump@crumplinux:~$ gulp --version
[20:05:28] CLI version 1.4.0
[20:05:28] Local version 3.9.1
mbcrump@crumplinux:~$ mongod --version
db version v2.6.10
2017-09-20T20:11:43.087+0000 git version: nogitversion
2017-09-20T20:11:43.095+0000 OpenSSL version: OpenSSL 1.0.2g  1 Mar 2016

Step 2

Create a folder such as webapp and then $ cd webapp.

Step 3

Run the following command in the webapp folder.

git clone https://github.com/crpietschmann/jsQuizEngine.git.

This is a JavaScript based quiz engine by Chris Pietschmann.

Step 4

Change your working directory to jsQuizEngine/src and now we’ll need to create a deployment user that can deploy web app through git.

az webapp deployment user set --user-name {your-username} --password {your-password}

Name    PublishingUserName
------  --------------------
web     mbcrump

Step 5

We’ll need a resource group. I’m going to put mine in the West US.

az group create --name StaticResourceGroup --location "West US"

Location    Name
----------  -------------------
westus      StaticResourceGroup

Step 6

We’ll also need an Azure App Service Plan. I’ll use the free one for this example.

az appservice plan create --name StaticAppServicePlan --resource-group StaticResourceGroup --sku FREE

AppServicePlanName    GeoRegion    Kind    Location      MaximumNumberOfWorkers  Name                  ProvisioningState    ResourceGroup        Status    Subscription
--------------------  -----------  ------  ----------  ------------------------  --------------------  -------------------  -------------------  --------  ------------------------------------
StaticAppServicePlan  West US      app     West US                            1  StaticAppServicePlan  Succeeded            StaticResourceGroup  Ready     d1ecc7ac-c1d8-40dc-97d6-2507597e7404

Step 7

We’ll create an Azure Web App and deploy it using local git.

Remember! Your URL will be unique and different than the ones you see in the example snippets.

az webapp create --name MyQuizApplication --resource-group StaticResourceGroup --plan StaticAppServicePlan --deployment-local-git

You should see something like this in the output:

Local git is configured with url of 'https://mbcrump@myquizapplication.scm.azurewebsites.net/MyQuizApplication.git'

Copy and paste this to your editor of choice.

Step 8

We'll need to add azure as a remote repository so that we can easily push updates from our local git repository. Be sure to update the command below to your specific credentials and unique URL.

git remote add azure https://mbcrump@myquizapplication.scm.azurewebsites.net/MyQuizApplication.git

Step 9

Push the changes.

git push azure master

Step 10

Nice! We can now browse to our new site.

Once you get a hang of using the CLI, then these steps become natural.

Want to dig further into the Azure CLI? Start here.

We'll be posting articles every day in April, so stay tuned or jump ahead and check out more tips and tricks now.