Adding Docker to an ASP.NET Core Application

I have a series of post about deploying an ASP.NET Core application to different cloud providers which centered around clouds that provided a service that supported ASP.NET Core. The following are all the post in that vein if you are interested.

Google Cloud Platform
Amazon Web Services
Microsoft Azure

I was asked if I was going to do a post on deployment to DigitalOcean. While not in my original plan it was a good idea. The thing is DigitalOcean doesn’t have a service to support ASP.NET Core, but they do support Docker so this post is going to cover adding Docker support to a sample ASP.NET Core application. Look for a future post on how to deploy to DigitalOcean.

Docker

What is Docker? To quote Wikipedia:

Docker is a computer program that performs operating-system-level virtualization also known as containerization. It was first released in 2013 and is developed by Docker, Inc.

Docker is used to run software packages called “containers”. In a typical example use case, one container runs a web server and web application, while a second container runs a database server that is used by the web application. Containers are isolated from each other and use their own set of tools and libraries; they can communicate through well-defined channels. All containers use the same kernel and are therefore more lightweight than virtual machines. Containers are created from “images” which specify their precise contents. Images are often created by combining and modifying standard images downloaded from repositories.

Installing Docker

Head to this link and click the Get Docker link to download the installer. After the install is complete you will have to log out and back in. When I logged back in I got a message about Hyper-V not being enabled.

After logging back in I then got the following message about hardware-assisted virtualization not being enabled.

After tweaking my BIOS settings and logging back in I was greeted by the Docker welcome screen.

Open a command prompt and run the following command.

You should output that starts with the following if your installation is working.

Hello from Docker!
This message shows that your installation appears to be working correctly.

Sample Application

This is the same as in the cloud series, but am including it in case you missed that post. The sample application that we will be deploying is the basic Razor Pages applications created using the .NET CLI. The following commands are what I used to create the application, create a solution, and add the project to the solution. I ran all these commands in a  CloudSample directory.

Add Docker Support

Open the solution created above in Visual Studio and right-click the project and select Add > Docker Support.

Next, you will have the select the OS you want to target.

This will add the following four files to your project.

The process will also change your project to start in Docker when you hit run from in Visual Studio.

Publishing

In order to publish we need an account with a registry that we want to publish to. There are multiple options, but I am going to be using Docker Hub. Go to Docker Hub and sign up for an account. After you get signed in on your Repositories tab click Create Repository.

On the next page enter a name for your repository, select if you want it to be private or public and click Create. I’m using the name TestRepository and making it private.

Now that we have a Docker Hub account hope back to Visual Studio and right-click on your project and select Publish.

On the next on the dialog select the Container Registry option and then Docker Hub. Then click the Publish button.

On the next dialog enter your username and password for Docker Hub and click Save.

After saving Visual Studio will build and publish the application to Docker Hub.

Issues

If you get luck the above will work for you. I hit a couple of issues that made the above fail for some reason. The following is the first error I got.

Error: Service ‘cloudsample’ failed to build: The command ‘/bin/sh -c dotnet restore /CloudSample.csproj’ returned a non-zero code: 1

After some digging, I found this GitHub issue. The gist of the fix is to change the following in the DockerFile.

The above fixed the build when in release mode, but publish still failed on me with the following error when the tools were attempting to tag the image.

System.Exception: Running the docker.exe tag command failed.
at Microsoft.VisualStudio.Web.Azure.Publish.ContainerRegistryProfileVisual.DockerTag(ProcessStartInfo startInfo, String serverUrlString)
at Microsoft.VisualStudio.Web.Azure.Publish.ContainerRegistryProfileVisual.<PostPublishAsync>d__24.MoveNext()
— End of stack trace from previous location where exception was thrown —
at System.Runtime.CompilerServices.TaskAwaiter.ThrowForNonSuccess(Task task)
at System.Runtime.CompilerServices.TaskAwaiter.HandleNonSuccessAndDebuggerNotification(Task task)
at Microsoft.VisualStudio.ApplicationCapabilities.Publish.ViewModel.ProfileSelectorViewModel.<RunPublishTaskAsync>d__116.MoveNext()

I haven’t found a way to get around this issue. I ended up using the Docker CLI to push my image. This takes a few steps. First, use the following command to log in.

Next, use the  docker images command to find the image you are trying to push. In my case, it was the image with ID f83e5adab340. When the ID we can now use the following command to tag the image.

It is important that the image is tagged with the name of the repository it is going to be pushed to. Finally, run the following command to push the image with the specified tag into your repository.

Wrapping Up

The teams at Microsoft have made adding Docker support to an existing project super simple. Docker is something that I have had a surface level awareness of for a while, and I am looking forward to trying an actual deployment to see how that works with DigitalOcean.

GraphQL using .NET Boxed: Subscriptions

This post is going to continue my exploration of GraphQL using the .NET Boxed template as a jumping off point. The code I am starting with can be found here. Check out GraphQL using .NET Boxed: Mutations from last week for an exploration of mutations.

Subscriptions are GraphQL’s way of allowing a client to request notification of changes to the data.

Starting Point

As discovered a few weeks ago,  MainSchema is the central point to finding how GraphQL is set up in this template. For reference here is the full class.

Today we are interested in the  Subscription property which is being assigned a SubscriptionObject.

Subscription Object

The following is the full  SubscriptionObject for reference. I will point out a few details after the code.

A lot of this is going to look very similar to the other types we have reviewed for queries and mutations. For example, the  Type is  HumanCreatedEvent which derives from  HumanObject which is  ObjectGraphType around the  Human class.

One of the hardest things exploring GraphQL is getting a good handle on the object graph. I highly recommend you spend some time in these classes getting the connection solid in your mind.

As another example that should look pretty similar to things we coved in the other post is the  Resolver which is dealing with the base  Human type.

This next bit is new and deals with the actual notification of GraphQL when the  HumanRepository creates a new human. The following code has had the home planet related stuff removed for clarity.

What is  WhenHumanCreated? Looks like it is an observable provided by the HumanRepository.

Looking at the  AddHuman function you will see that this observable is provided a new value everytime a human is created which in turn provides notification to our GraphQL setup to notify any clients that are subscribed that a new human was added.

Wrapping Up

That covers my exploration of subscriptions. For me, this was the coolest part of the things I have seen in GraphQL.

I know this was a bit of a strange series as we just looked at the code generated by a template. I hope you found it useful. I know it helped me get a better grip on the idea behind GraphQL and how it can be handled in .NET Core.

The associated sample code can be found here.

GraphQL using .NET Boxed: Mutations

This post is going to continue my exploration of GraphQL using the .NET Boxed template as a jumping off point. The code I am starting with can be found here. Check out GraphQL using .NET Boxed: Queries from last week for an exploration of queries.

Mutations are GraphQL’s way of allowing a client to request changes to the data on the server-side.

Starting Point

As we discovered last week,  MainSchema is the central point to finding how GraphQL is set up in this template. Just for reference here is the full class.

We are interested in the  Mutation property which is being assigned a  MutationObject.

Mutation Object

The following is the full  MutationObject class which defines what mutations are allowed for which objects on this server and what happens when a mutation request is received.

This is very similar to have the  QueryObject from last week was set up. The first big difference is in the  QueryArguments. The mutation is taking a  HumanInputObject class instead of an ID. If you look at the query argument you will also see that this argument isn’t allowed to be null.

What is the  HumanInputObject class? It is an  InputObjectGraphType and defines the shape of what the mutation query argument looks like. As you can see in the following it provides a name, description, and list of fields.

Also, note that the fields are using  nameof on the properties of the  Human class to make sure the names match which will prevent any problems with the mapping between the 3 different human classes this project is working with. Here is an example of the field definition pulled out from the above sample.

Another thing to make note of is that even at the field level you can set if a field is allowed to be null or not on top of setting the type of the field.

Back over in the  MutationObject let’s look at the resolve inside of the FieldAsync call.

This is pulling the  human query argument and it is being translated into an instance of the  Human class and then sent to the repository to be saved.

Wrapping Up

That covers the basic exploration of mutations. I’m thinking about looking at subscriptions.

The associated sample code can be found here.

GraphQL using .NET Boxed: Queries

This post is going to continue my exploration of GraphQL using the .NET Boxed template as a jumping off point. The code I am starting with can be found here. If you want to start at the very basics of getting the .NET Boxed templates installed, check out my ASP.NET Core with GraphQL using .NET Boxed post.

Finding a Thread

As stated in the last post the backing data for the project is in a static class found in the Repositories/Database.cs file. The data is Star Wars themed and consists of two lists of characters one for droid and one for humans which get combined into a list of characters.

Instead of starting with the data and finding where it is used I’m going to approach this from the perspective of the way the application handles requests. For an ASP.NET Core application, this means looking at the  Configure function of the  Startup class, which is where the HTTP pipeline is configured.

In the  Configure function, we find the following two calls related to GraphQL. I dropped the actual setting of options out of both calls.

Looks like  MainSchema is the thread we needed to follow.

MainSchema

There isn’t a lot of code in the  MainSchema class. The following is the full class as it was generated by the template.

The  Schema class that is the base class is provided by the GraphQL for .NET library. Just like any other schema in GraphQL it is used to define the data available to the client and the types of queries that can be used. For now, we are going to stick with following the  Query type and leave  Mutation and  Subscription for future posts.

Query Object

For the template, we are using the schema for queries is located in the  QueryObject class. Below is the class but simplified to only include the setup of one entity. For our sample Star Wars data, I am using the human bits and dropping the droids.

The class  Constructor needs an instance of a class that is used to access the data for the entity the query is being defined for, in this case, an  IHumanRepository.

The key bit in this class is the  FieldAsync<HumanObject, Human> call. It is the definition of the query allowed for getting a single human. The first parameter is the name of the query, the second is the query’s description.

Next, are the arguments the query needs to execute.

In this example, the query can take a single argument for the ID of the human to be returned. The final bit is how this query should be resolved to the actual backing data.

Here the  context allows us to pull the parameters passed by the client using the  context.GetArgument function call with name, as defined in the argument section, and use them in the call to the  humanRepository.

Object Graph Type

The last point I want to touch on is the difference between the two types on the  FieldAsync<HumanObject, Human> call.  Human is the type the entity used by the data access.  HumanObject is  Human wrapped in an  ObjectGraphType. The following is the full  HumanObject class.

This pattern allows extra metadata to be added to the type being wrapped. You can see this work in the schema area playground that the sample application launches when in development mode.

Wrapping Up

My previous post on GraphQL left me feeling like it was pretty magical. That is true from the client side perspective. From the server side, that magic comes with some complexity. Don’t take that as a judgment on GraphQL it is just one of the aspects that must be considered before selecting a technology. As I get more familiar with the server side of GraphQL I’m sure some of what I am seeing as complexity when just learning will become clear.

The associated sample code can be found here.

Limit Failure

My family and I just got back from our first really big trip since our son was born six years ago. We had a ton of fun and it was a great experience for us all. While we were gone I intentionally let a few things drop such as my diet, exercise, reading, and podcasts. For my everyday life letting all of those things drop is a big failure.

Letting go is OK

Let me lead by saying letting things go is OK. None of us can be on plan 100% of the time especially if any of the things you are doing require your willpower to get done. Check out Willpower Doesn’t Work for more information on why using willpower to change your life isn’t a good idea.

Plan, plan, plan

Having a plan for how far off of the rails you are going to go can help limit the damage you do. For example, planning to have one unrestricted meal a day lets you have some freedom while on vacation while limiting your downside versus what it would be if you just went off the rails completely. The key for me in the future will be finding the right balance between my normal routine and not affecting the enjoyment of the trip.

I haven’t tried this yet, but I have read going to the point of visualizing the challenges you might face and how you will respond to them can be a very powerful way of making sure you stick with your plan. Then instead of having to make choices at the moment, you can fall back to going with what you visualized.

This all comes down to not having to make a judgment call at the moment you face the situation. When making calls at the moment we tend to choose the option with the most immediate reward, not the one that is the best long-term.

Back to reality

When everything is over getting back into your normal routine can be hard. If you planned fully then this transition is planned and you just have to execute. Again taking the decision away from the moment.

For our trip, the transition didn’t go as planned. We had numerous delays in flights, unforeseen things to take care of after getting home. We have been back for close to a week now and I still haven’t gotten back on track with all of my activities.

You can’t plan for everything, but that doesn’t mean you don’t plan. When faced with unforeseen events you have to make the best choice you can at the moment and move on. As soon as you have the chance to reevaluate where you are and then adjust course.

The key point is we are all going to fail and that is OK, but we want to limit the downside of our failures as much as we can. Evaluate and adjust. Don’t beat yourself up over failing. Learn.

ASP.NET Core with GraphQL using .NET Boxed

GraphQL is something I have been meaning to look into for awhile, but haven’t found the time. Muhammad Rehan Saeed recent release of .NET Boxed, which is a rebranding of his ASP.NET Core Boilerplate templates, contains a template for GraphQL. This brought GraphQL back to the front of my mind so this post is going to walk through installing and using .NET Boxed to get a GraphQL project up and running.

Template Installation

As with all templates, installation is very easy using the .NET CLI. Open a command prompt and enter the following command.

The * at the end of the command is just making sure the latest version gets installed. After the installation is done you will get a list of all the template you have installed. The two new ones provided by .NET Boxed are highlighted in the screenshot.

Project Creation

For this post, we will be creating a project using the graphql template. Both of the templates provided by .NET Boxed have a lot of optional flags that can be used configure the resulting project. Make sure to run the help command for the template you are using to see if there are any option you want to set. For example, the following command would list all the options for the GraphQL template.

Create and navigate to the directory you want the new project to be created in and then run the following command to create the project with the default setting with the exception of turning off HTTPS. Not something you want to turn off for a production application, but it reduces the complexity of the initial exploration.

With the project created run the following command from the same directory to open it in Visual Studio Code.

Some Project Notes

The project generation creates a ReadMe.html in the root of the project. Make sure and check it out. It has a list of pre-requisites needed for the project as well as a lot of good information on general good practices.

We aren’t going to dig too far into the project itself in this post, but it is helpful to know where the data lives and what it looks like for when we are trying out some GraphQL queries. The backing data is in a static class found in the Repositories/Database.cs file.

The data is Star Wars themed and consists of two lists of characters one for droid and one for humans which get combined into a list of characters. The following is the  Database class for reference.

Try it out

When you run the project in development mode (the default) it will show a GraphQL playground which is made available by GraphQL.NET. It looks like the following.

Box 1 is the area where you enter the query you want to execute against the GraphQL backend. Box 2 is the play button which sends the query to the backend. Finally, box 3 is where the results of the query are displayed.

The following query is asking for ID, Name, and Appears In properties for the human that matches the provided ID.

On our sample data, the query returns the following.

Now let’s try creating a new human. Clear the query area and enter the following query.

If you tried to run the above it would fail. For this query to work we need to define what  $human is. You do this in the Query Variables area which is right below box 1 in the screenshot above. Enter the following and hit the play button.

This will result in the following. Your ID will be different of course.

Wrapping Up

The above information is enough to get started playing with GraphQL with ASP.NET Core. There is a lot more that I want to dig into so look for more posts on these topics. The code can be found here.

Deploying an ASP.NET Core Application to Microsoft Azure

This is the third post in a series on deploying a very simple ASP.NET Core application to the major cloud provides. This post is going to be dealing with setup and deployment to Microsoft Azure.

The following is are the other posts in this series.

Google Cloud Platform
Amazon Web Services
Microsoft Azure (this post)

Sample Application

This is the same as the first post in the series, but am including it in case you missed that post. The sample application that we will be deploying is the basic Razor Pages applications created using the .NET CLI. The following commands are what I used to create the application, create a solution, and add the project to the solution. I ran all these commands in a  CloudSample directory.

Microsoft Azure

The rest of this post is going to be based on the official Create an ASP.NET Core web app in Azure documentation. I already have all the Azure related stuff installed and have used it before, so it will be much easier for me to miss a step. If that happens please leave a comment and I will get the post fixed.

Azure Development for Visual Studio

The additional tools need to use Azure from Visual Studio are part of the Visual Studio installer. I’m assuming that Visual Studio is already installed. To add Azure select the Tools > Get Tools and Features menu.

After the installer launches close all instances of Visual Studio. From the list of features select Azure development and click the Modify button to start the installation.

Sign up for Azure

While the tools are installing is a good time to sign up for Azure if you don’t already have an account. You can sign up here. This is one of the parts that doesn’t work well when you already have an account, but the link above should guide you through the process.

Application Publication

Hope back in Visual Studio and open the solution you want to publish. In the Solution Explorer window right click on the project and select the Publish menu option.

This will show the publish target dialog where you can select what you want to publish to. In this example, we are going to be publishing to an App Service. The details area select Create New option. Then click the Publish button to move to the next screen

The next step collects the information needed to Create an App Service. The first thing to set is the account in the upper right corner of the screen. This could already be set based on how you are logged in to Visual Studio. Next, click the New link next to the Resource Group and enter the name you want to use. Then click the New link next to the Hosting Plan.

In the Hosting Plan dialog, you get options to give the plan a name, pick your hosting location, and the size. For the Size, I recommend starting with the Free option. After all the options are set click OK.

This will return you to the Create App Service dialog where you can click the Create button to deploy the application. After deployment finishes the site will open in your default browser.

Wrapping Up

For me using Azure from Visual Studio is the simplest experience of all the cloud providers I have tried so far. I don’t guess that is surprising since Microsoft controls both products. Forgetting the integration with Visual Studio it seems that Azure App Services, Google App Engine, and Amazon Elastic Beanstalk are all on par with each other.

As always don’t for get to shutdown/delete the assocated resources for your test project to avoid changes.

Deploying an ASP.NET Core Application to Amazon Web Services

This is the second post in a series on deploying a very simple ASP.NET Core application to the major cloud provides. This post is going to be dealing with setup and deployment to Amazon Web Services (AWS).

The following is are the other posts in this series.

Google Cloud Platform
Amazon Web Services (this post)
Microsoft Azure

Sample Application

This is the same as the first post in the series, but am including it in case you missed that post. The sample application that we will be deploying is the basic Razor Pages applications created using the .NET CLI. The following commands are what I used to create the application, create a solution, and add the project to the solution. I ran all these commands in a  CloudSample directory.

Amazon Web Services

The rest of this post is going to be based on a couple pieces of documentation from Amazon for the Visual Studio Toolkit and Beanstalk with .NET Core. I will be walking through the whole process but wanted to make sure you had access to the same information this post is based on.

AWS Toolkit for Visual Studio

Amazon provides a Visual Studio extension to aid in interactions with their platform from Visual Studio. To install open the Tools > Extensions and Updates menu. Select Online from the left side of the dialog and then search for AWS and select AWS Toolkit for Visual Studio 2017.

Click download, close Visual Studio to trigger installation, and restart Visual Studio after the extension’s installation has completed. When you open Visual Studio back up you should see the AWS Getting Started page with has this link to the IAM Users page in the AWS Console. This will land you on the following page where you have to either sign into your account or sign up for a new account.

After you get through the sign-up/in process you will be at the IAM console where we are going to add a new user by clicking the Add user button.

On the next page fill out the User name you want to use and check the Programmatic access check box and then click the Next: Permissions button.

The next page is all about what permissions the user will have which is handled via groups. Since my account doesn’t have any groups I need to create one using the Create group button.

On the Create group form enter the Group name you want to use. Next, use the search box for Policy type to find the policies related to Elastic Beanstalk. I have selected the full access policy for this sample, but if it is more than just a test this would require more research to see if that is the proper policy to use or not. When done click the Create group button.

This will return you to the group page from above. Click the Next: Review button to continue. The next page is just a review of the options selected on previous pages. Click the Create user button to continue.

The last page has a button to Download .csv, click it and download the file. Back over in Visual Studio on the AWS Getting Started page click the Import from csv file.

Browse and select the csv download above. Then click the Save and Close button on the AWS Getting Started page. After that is complete you should see the AWS Explorer window.

Sign up for AWS Elastic Beanstalk

If you notice in the AWS Explorer screenshot above the Please sign up for this service under AWS Elastic Beanstalk. Double click the Please sign up for this service it will open a new browser window. On this window click the Get started with AWS Elastic Beanstalk button.

The next page will prompt for payment information. After entering your information click the Secure Submit button. The next step is an automated phone call to verify that you who you say you are. The final step in signing up is to select your plan.

Select the Free plan to finish your sign up.

Publishing from Visual Studio

Now that sign up is complete hope back in Visual Studio and open the solution you want to publish. In the Solution Explorer window right-click on the project and click Publish to AWS Elastic Beanstalk.

This will open the Publish to Amazon Web Services dialog. I just took the defaults since this is a new application and I don’t have any existing enviroments. Click the Next button to continue.

On the next screen, an Application Name and Environment Name are needed. Fill them in and click Next.

The next screen is where you can configure the type and size of the EC2 instance that will back your application. I used the defaults. As always click Next when ready.

The next screen allows you to configure permissions. You will never guess, but I used the defaults and clicked Next.

The next screen allows you to pick your project build configuration and framework to use. The defaults are set based your project so they should be right. Click the Finish button.

The final screen is to review all the options. If you are happy with everything click the Deploy button.

During deployment, I saw the following error in my output window.

Caught AmazonIdentityManagementServiceException whilst setting up role: User:myUser/CloudSampleBlog is not authorized to perform: iam:GetInstanceProfile on resource: instance profile aws-elasticbeanstalk-ec2-role
Caught Exception whilst setting up service role: User: myUser/CloudSampleBlog is not authorized to perform: iam:PutRolePolicy on resource: role aws-elasticbeanstalk-service-role

This turned out to not really be an issue. I went to my Elastic Beanstalk Dashboard and the application was there and in the process of deploying. The whole process took around 5 minutes. Unlike with Google, I did have to find the URL in the dashboard instead of a browser being opened to the URL automatically.

Wrapping Up

Initial setup with AWS is much more complex than with Google. Redeployment was in the two-minute range which is much faster than what I saw with Google. Overall it seems that Elastic Beanstalk is on par with Google’s App Engine.

Don’t forget to shut down and/or delete your test project when you are finished to make sure you don’t get charged.

Deploying an ASP.NET Core Application to Google Cloud Platform

This is the first post in what is going to be a series on deploying a very simple ASP.NET Core application to the major cloud providers starting with Google’s cloud. This series was inspired by a question from one of my coworkers about the ease-of-use differences for .NET between the cloud providers.

The other posts in the series:
Google Cloud Platform (this post)
Amazon Web Services
Microsoft Azure

Sample Application

The sample application that we will be deploying is the basic Razor Pages applications created using the .NET CLI. The following commands are what I used to create the application, create a solution, and add the project to the solution. I ran all these commands in a  CloudSample directory.

Google Cloud Platform

The rest of this post is going to be based on information from Google which can be found here.

Google Cloud SDK Installation

The first step is to download and install the Google Cloud SDK which can be found here. I’m walking through these steps for Windows, but the previous link has instructions for Linux and Mac as well.

After downloading and run the installer, and be patient it takes awhile to run. When it is done you should see the following screen.

Make sure and leave the bottom two boxes checked as  gcloud init must be complete to get everything working as it should. Click the Finish button and a console will open and walk you through the initialization process.

The first step in the process will open a web browser and ask you to login to your Google account. After logging in you will be asked for a cloud project to use. It should look something like the following.

We want to select  Create a new project which is option 4 in my case. When prompted for a project ID I just hit enter and it let me out of the process so I don’t think a project is actually required at this point so that is a little confusing.

Google Cloud Tools for Visual Studio Installation

Google provides a Visual Studio extension that makes interacting with their platform simpler from within Visual Studio. To install open the  Tools > Extensions and Updates menu. On the left select  Online and then search for  Google. Next, select  Google Cloud Tools for Visual Studio.

Click download, close Visual Studio to trigger installation, and restart Visual Studio. Now that the extension is installed we need to connect it to an account. Using the   Tools > Google Cloud Tools > Manage Accounts menu to launch the Manage Accounts Dialog. Next click  Add Account.

This will launch a web browser where you will need to complete the account add. After the account auth completes Visual Studio should show the  Google Cloud Explorer window logged in the account you selected.

Create an App Engine Project

Open App Engine and click Create.

On the next page, you will need to give the project a name and then click Create.

On the next page select .NET as your language.

And select the location you want your application hosted in and click next.

If you aren’t already signed up then the next step signs you up for a 12 month trial with $300 worth of credit. Click the Signu up for free trial button to continue.

On the next screen, for the trial, you have to select your county as well as agree to the terms.

The next screen is a summary of your account. Review the information and click the Start my free trial button to continue.

Deploy from Visual Studio

In the Google Cloud Explorer window in Visual Studio select the project you just created in the drop-down.

If you don’t see your new project try clicking the refresh button in the upper left-hand side of the window. Now that you have the correct project selected switch over to the  Solution Explorer window and right click on your project and select  Publish to Google Cloud.

On the next screen select  App Engine Flex.

Then on the next screen click publish.

My first deployment took a really long time so don’t worry if you end up waiting a while (5 to 10 minutes). I tried a second deployment and it took just as long so I guess that is just how long it takes. When deployment finished it should open your site in a web browser.

Wrapping Up

After the initial set of installs and setup, Google Cloud with ASP.NET Core is pretty straightforward. The deployment time seems way too long, but that is really the only complaint I have.

Don’t forget to shut down and/or delete your test project when you are finished to make sure it doesn’t use up your credits.

Migration from ASP.NET Core 2.0 to 2.1

On May 30th .NET Core 2.1 was released including the corresponding version of ASP.NET Core 2.1 and Entity Framework Core 2.1. In this post, I will be taking one of the projects used in my ASP.NET Basics series and converting it from its current 2.0.x version into the newly released 2.1 version. The starting point for the code can be found here. This is all based on the official migration guide.

If you are looking at the sample solution it is the Contacts project that this post is going to be dealing with.

Installation

Thankfully the download page is much improved over the last time there was a release. Head here and to download and install the .NET Core 2.1 SDK. It is available for Windows, Linux, and Mac. The link should drop you on the appropriate page for your OS.

After installation, open a command prompt and run the following command. If all worked well you should see version 2.1.300 listed.

If you are on Windows make sure and install at least Visual Studio 2017 15.7.

Project File Changes

Right-click on the project and select Edit {projectName}.csproj from the menu.

First, change the TargetFramework to netcoreappp2.1.

The other required changes it to move away from the Microsoft.AspNetCore.All package to the version-less Microsoft.AspNetCore.App package.

I did a bit more digging and it turns out that the project file can be greatly simplified from the version I had for this application. The following is the full project file will all the bits that were not required removed and the two changes above already made.

Main Changes

There have been changes to how what the  Main function looks like to better allow for integration tests. This is the original code in the Program.cs file.

And the following is the new version.

Startup Changes

Startup.cs has one change that is required which is the removal of the following line from the  Configure function.

In the  ConfigureServices function if you want to use the new features in 2.1 change the  services.AddMvc() to set the compatibility version. This allows you to upgrade the version of the SDK without having to change your whole application since you have to opt into the version you want to target.

If you check out the official migration guide they also point out how to enable a couple more features such as HTTPS and some things to help with GDPR. Neither of these is needed in this application so I’m skipping them in this guide.

Identity Changes

I had to make one change in ManageLogins.cshtml to get my project to build because of a rename/removal AuthenticationScheme to DisplayName.

If you haven’t made many changes to the identity code in your project you might consider using the new identity razor class library. You can find the details here.

Wrapping Up

Migrations between versions of ASP.NET Core have gotten easier over time as you can tell by the smaller length of these posts. One thing to note is while this will get you targeting 2.1 with all the performance benefits and access to a lot of the new features there will still be work needed if you want to do everything the new 2.1 style. I highly recommend creating a new 2.1 application to get a feel for the other changes you might want to make to your existing applications.

The code with all the changes can be found here. Remeber that the only project that was upgraded was the Contacts project.