Nat  Kutch

Nat Kutch

1595494260

NET Core app using Docker, Azure DevOps, Azure Container Registry

This is a guide on how to use Azure DevOps to build and then publish a docker image as an Azure App Service, using Azure Container Registry.

Prerequisites

This guide assumes basic knowledge in Docker and more specifically how to create a Dockerfile. This docker cheat sheet provides a ready Dockerfile with explanations, plus an easy way to create your own Dockerfile from within Visual Studio. The guide also requires an account on Azure and Azure DevOps. The code is hosted in Azure DevOps, but almost any -accessible from Azure DevOps- version control system will do.

In the process that follows, we setup three things mainly; An Azure Container Registry to hold the Docker Image, an Azure DevOps Pipeline to build and push the image to the registry, and and Azure App Service that will continuously pull the image from the registry.

Steps to setup Azure Container Registry

In order to setup an Azure Container Registry, you will of course need to visit portal.azure.com first. After signing in, follow the next three steps to setup and configure Azure Container Registry correctly:

Step 1

Use the convenient search bar on top to search for “Container Registry“. Once the results are in, click on the left side on the “Container Registry” result, as shown here:

Azure Container Registry - Search

Step 2

Once you clicked on the correct result, the “Create Container Registry” form will appear and a few selections have to be made. The minimum changes required here, are to select the Subscription and Resource group you wish (you can also create a new recourse), and to write the Registry name you prefer. Change the Location and SKU if needed and click Create once done.

Azure Container Registry - Create

The Registry name is part of the Login Server for your Azure Container Registry. In this example it will be registryaspnetcoredockerdemo.azurecr.io.

Step 3

Enable the Admin user for this Container Registry. Although the admin account is designed for a single user to access the registry, mainly for testing purposes, in order to be able to use the current registry from an App Service and select image source and Continuous Deployment, the Admin user must be enabled. Find this resource and go to Access Keys to enable the Admin user, as shown below:

Azure Container Registry - Enable Admin User

Read more information about the Admin Account in Microsoft Docs

#azure #docker #azure app service #azure devops #devops

What is GEEK

Buddha Community

NET Core app using Docker, Azure DevOps, Azure Container Registry
Einar  Hintz

Einar Hintz

1602560783

jQuery Ajax CRUD in ASP.NET Core MVC with Modal Popup

In this article, we’ll discuss how to use jQuery Ajax for ASP.NET Core MVC CRUD Operations using Bootstrap Modal. With jQuery Ajax, we can make HTTP request to controller action methods without reloading the entire page, like a single page application.

To demonstrate CRUD operations – insert, update, delete and retrieve, the project will be dealing with details of a normal bank transaction. GitHub repository for this demo project : https://bit.ly/33KTJAu.

Sub-topics discussed :

  • Form design for insert and update operation.
  • Display forms in modal popup dialog.
  • Form post using jQuery Ajax.
  • Implement MVC CRUD operations with jQuery Ajax.
  • Loading spinner in .NET Core MVC.
  • Prevent direct access to MVC action method.

Create ASP.NET Core MVC Project

In Visual Studio 2019, Go to File > New > Project (Ctrl + Shift + N).

From new project window, Select Asp.Net Core Web Application_._

Image showing how to create ASP.NET Core Web API project in Visual Studio.

Once you provide the project name and location. Select Web Application(Model-View-Controller) and uncheck HTTPS Configuration. Above steps will create a brand new ASP.NET Core MVC project.

Showing project template selection for .NET Core MVC.

Setup a Database

Let’s create a database for this application using Entity Framework Core. For that we’ve to install corresponding NuGet Packages. Right click on project from solution explorer, select Manage NuGet Packages_,_ From browse tab, install following 3 packages.

Showing list of NuGet Packages for Entity Framework Core

Now let’s define DB model class file – /Models/TransactionModel.cs.

public class TransactionModel
{
    [Key]
    public int TransactionId { get; set; }

    [Column(TypeName ="nvarchar(12)")]
    [DisplayName("Account Number")]
    [Required(ErrorMessage ="This Field is required.")]
    [MaxLength(12,ErrorMessage ="Maximum 12 characters only")]
    public string AccountNumber { get; set; }

    [Column(TypeName ="nvarchar(100)")]
    [DisplayName("Beneficiary Name")]
    [Required(ErrorMessage = "This Field is required.")]
    public string BeneficiaryName { get; set; }

    [Column(TypeName ="nvarchar(100)")]
    [DisplayName("Bank Name")]
    [Required(ErrorMessage = "This Field is required.")]
    public string BankName { get; set; }

    [Column(TypeName ="nvarchar(11)")]
    [DisplayName("SWIFT Code")]
    [Required(ErrorMessage = "This Field is required.")]
    [MaxLength(11)]
    public string SWIFTCode { get; set; }

    [DisplayName("Amount")]
    [Required(ErrorMessage = "This Field is required.")]
    public int Amount { get; set; }

    [DisplayFormat(DataFormatString = "{0:MM/dd/yyyy}")]
    public DateTime Date { get; set; }
}

C#Copy

Here we’ve defined model properties for the transaction with proper validation. Now let’s define  DbContextclass for EF Core.

#asp.net core article #asp.net core #add loading spinner in asp.net core #asp.net core crud without reloading #asp.net core jquery ajax form #asp.net core modal dialog #asp.net core mvc crud using jquery ajax #asp.net core mvc with jquery and ajax #asp.net core popup window #bootstrap modal popup in asp.net core mvc. bootstrap modal popup in asp.net core #delete and viewall in asp.net core #jquery ajax - insert #jquery ajax form post #modal popup dialog in asp.net core #no direct access action method #update #validation in modal popup

Nat  Kutch

Nat Kutch

1595494260

NET Core app using Docker, Azure DevOps, Azure Container Registry

This is a guide on how to use Azure DevOps to build and then publish a docker image as an Azure App Service, using Azure Container Registry.

Prerequisites

This guide assumes basic knowledge in Docker and more specifically how to create a Dockerfile. This docker cheat sheet provides a ready Dockerfile with explanations, plus an easy way to create your own Dockerfile from within Visual Studio. The guide also requires an account on Azure and Azure DevOps. The code is hosted in Azure DevOps, but almost any -accessible from Azure DevOps- version control system will do.

In the process that follows, we setup three things mainly; An Azure Container Registry to hold the Docker Image, an Azure DevOps Pipeline to build and push the image to the registry, and and Azure App Service that will continuously pull the image from the registry.

Steps to setup Azure Container Registry

In order to setup an Azure Container Registry, you will of course need to visit portal.azure.com first. After signing in, follow the next three steps to setup and configure Azure Container Registry correctly:

Step 1

Use the convenient search bar on top to search for “Container Registry“. Once the results are in, click on the left side on the “Container Registry” result, as shown here:

Azure Container Registry - Search

Step 2

Once you clicked on the correct result, the “Create Container Registry” form will appear and a few selections have to be made. The minimum changes required here, are to select the Subscription and Resource group you wish (you can also create a new recourse), and to write the Registry name you prefer. Change the Location and SKU if needed and click Create once done.

Azure Container Registry - Create

The Registry name is part of the Login Server for your Azure Container Registry. In this example it will be registryaspnetcoredockerdemo.azurecr.io.

Step 3

Enable the Admin user for this Container Registry. Although the admin account is designed for a single user to access the registry, mainly for testing purposes, in order to be able to use the current registry from an App Service and select image source and Continuous Deployment, the Admin user must be enabled. Find this resource and go to Access Keys to enable the Admin user, as shown below:

Azure Container Registry - Enable Admin User

Read more information about the Admin Account in Microsoft Docs

#azure #docker #azure app service #azure devops #devops

Mikel  Okuneva

Mikel Okuneva

1602317778

Ever Wondered Why We Use Containers In DevOps?

At some point we’ve all said the words, “But it works on my machine.” It usually happens during testing or when you’re trying to get a new project set up. Sometimes it happens when you pull down changes from an updated branch.

Every machine has different underlying states depending on the operating system, other installed programs, and permissions. Getting a project to run locally could take hours or even days because of weird system issues.

The worst part is that this can also happen in production. If the server is configured differently than what you’re running locally, your changes might not work as you expect and cause problems for users. There’s a way around all of these common issues using containers.

What is a container

A container is a piece of software that packages code and its dependencies so that the application can run in any computing environment. They basically create a little unit that you can put on any operating system and reliably and consistently run the application. You don’t have to worry about any of those underlying system issues creeping in later.

Although containers were already used in Linux for years, they became more popular in recent years. Most of the time when people are talking about containers, they’re referring to Docker containers. These containers are built from images that include all of the dependencies needed to run an application.

When you think of containers, virtual machines might also come to mind. They are very similar, but the big difference is that containers virtualize the operating system instead of the hardware. That’s what makes them so easy to run on all of the operating systems consistently.

What containers have to do with DevOps

Since we know how odd happenings occur when you move code from one computing environment to another, this is also a common issue with moving code to the different environments in our DevOps process. You don’t want to have to deal with system differences between staging and production. That would require more work than it should.

Once you have an artifact built, you should be able to use it in any environment from local to production. That’s the reason we use containers in DevOps. It’s also invaluable when you’re working with microservices. Docker containers used with something like Kubernetes will make it easier for you to handle larger systems with more moving pieces.

#devops #containers #containers-devops #devops-containers #devops-tools #devops-docker #docker #docker-image

Trace  Hoeger

Trace Hoeger

1623318720

Integration Testing for ASP.NET Core using EF Core Cosmos with XUnit and Azure DevOps

This article shows how integration tests could be implemented for an ASP.NET Core application which uses EF Core and Azure Cosmos. The database tests can be run locally or in an Azure DevOps build using the Azure Cosmos emulator. XUnit is used to implement the tests.

Code: https://github.com/damienbod/AspNetCoreEfCoreCosmosTesting

EF Core is used to the access Azure Cosmos database. An EF Core **DbContext **was created to access Cosmos. This is like any EF Core context, with the **DBSet **definitions as required. Some Cosmos specific definitions are added using the **OnModelCreating **method. See the Cosmos-specific model customization for more details.

public class CosmosContext : DbContext

{

public CosmosContext(DbContextOptions<CosmosContext> options)

: base(options) { }

public DbSet<MyData> MyData { get; set; }

protected override void OnModelCreating(ModelBuilder modelBuilder)

{

modelBuilder.HasDefaultContainer(``"MyDataStore"``);

modelBuilder.Entity<MyData>()

.ToContainer(``"MyDataItems"``);

modelBuilder.Entity<MyData>()

.HasPartitionKey(o => o.PartitionKey);

modelBuilder.Entity<MyData>()

.Property(d => d.ETag)

.IsETagConcurrency();

}

}

The **MyData **class is is used to model the Cosmos documents. This has a **PartitionKey **and also an **ETag **which can be used for the Optimistic concurrency validation.

1

2

3

4

5

6

7

8

public class MyData

{

public string Id { get; set; }

public string PartitionKey { get; set; }

public string Name { get; set; }

public string Description { get; set; }

public string ETag { get; set; }

}

The **MyDataService **service class is used to access the context and implement some query logic as required. I like to keep this simple and not separate the specification of the queries from the the business or the Linq statements. This reduces the amount of code and keeps the data access, business simple and makes it easy to adapt.

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

public class MyDataService

{

private CosmosContext _cosmosContext;

public MyDataService(CosmosContext cosmosContext)

{

_cosmosContext = cosmosContext;

}

public void EnsureCreated()

{

_cosmosContext.Database.EnsureCreated();

}

public async Task CreateAsync(MyData myData)

{

await _cosmosContext.MyData.AddAsync(myData);

await _cosmosContext.SaveChangesAsync(false);

}

public async Task<MyData> Get(string id)

{

return await _cosmosContext.MyData.FirstAsync(d => d.Id == id);

}

public async Task<IList<MyData>> NameContains(string name)

{

return await _cosmosContext.MyData

.Where(d => d.Name.Contains(name)).ToListAsync();

}

}

The **ConfigureServices **method adds the services required to use EF Core and Cosmos DB. The services are used in a Razor page application, but this could be any web application, ASP.NET Core API or ASP.NET Core Blazor.

1

2

3

4

5

6

7

8

9

10

11

12

13

public void ConfigureServices(IServiceCollection services)

{

services.AddDbContext<CosmosContext>(options =>

{

options.UseCosmos(

"AccountEndpoint=[https://localhost:8081/;AccountKey=C2y6yDjf5/R](https://localhost:8081/;AccountKey=C2y6yDjf5/R)+ob0N8A7Cgv30VRDJIWEHLM+4QDU5DE2nQ9nDuVTqobD4b8mGGyPMbIZnqyMsEcaGQy67XIw/Jw=="``,

databaseName: "MyDataDb"

);

});

services.AddScoped<MyDataService>();

services.AddRazorPages();

}

The service needs to be tested. Instead of mocking away the database or using separate specifications classes as parameters, the service can be tested as one using Azure Cosmos emulator and EF Core. We used the framework tools to test our code. An EF Core in-memory database could also be used instead of the Azure Cosmos emulator. We use the emulator for these tests.

#.net core #asp.net core #web #azure #azure devops #asp.net

Osborne  Durgan

Osborne Durgan

1591093172

Create, Build, Deploy and Configure an Azure Function with Azure DevOps and Azure CLI

This post shows how to create, build, deploy and configure an Azure Function using Azure DevOps, Azure CLI and Powershell. An Azure Function is created in Azure using Azure DevOps with Azure CLI and Powershell. The Azure Function (V3) project is created and built using Visual Studio and C#. This project is deployed to the Azure infrastructure using a second Azure DevOps Pipeline. The Azure Function configuration settings is configured to use Azure Key Vault for secrets.

#asp.net core #azure #devops #.net core #azure devops #azure functions #cli #powershell