首页 > 系统相关 >Build ASP.NET Core applications deployed as Linux containers into an AKS/Kubernetes orchestrator

Build ASP.NET Core applications deployed as Linux containers into an AKS/Kubernetes orchestrator

时间:2023-10-16 15:24:59浏览次数:52  
标签:Core ASP orchestrator name Figure -- image project docker

原文:https://learn.microsoft.com/en-us/dotnet/architecture/containerized-lifecycle/design-develop-containerized-apps/build-aspnet-core-applications-linux-containers-aks-kubernetes

Azure Kubernetes Services (AKS) is Azure's managed Kubernetes orchestrations services that simplify container deployment and management.

The main features of AKS are:

  • An Azure-hosted control plane.
  • Automated upgrades.
  • Self-healing.
  • User-configurable scaling.
  • Simpler user experience for both developers and cluster operators.

The following examples explore the creation of an ASP.NET Core 6.0 application that runs on Linux and deploys to an AKS Cluster in Azure. Development is done using Visual Studio 2022 version 17.0.

Creating the ASP.NET Core Project using Visual Studio 2022

ASP.NET Core is a general-purpose development platform maintained by Microsoft and the .NET community on GitHub. It's cross-platform, supporting Windows, macOS and Linux, and can be used in device, cloud, and embedded/IoT scenarios.

This example uses a couple of simple projects based on Visual Studio templates, so you don't need much additional knowledge to create the sample. You only have to create the project using a standard template that includes all the elements to run a small project with a REST API and a Web App with Razor pages, using ASP.NET Core 6.0 technology.

For reference, you can download the sample from .NET Application Architecture's repo explore-docker.

Add new project window in Visual Studio, selecting ASP.NET Core Web Application.

Figure 4-35. Creating an ASP.NET Core Web Application in Visual Studio 2022.

To create the sample project in Visual Studio, select File > New > Project, select the Web project type and then the ASP.NET Core Web Api template. You can also search for the template if you need it.

Then enter the application name and location as shown in the next image.

Enter the project name and location.

Figure 4-36. Enter the project name and location in Visual Studio 2022.

Verify that you've selected ASP.NET Core 6.0 as the framework. .NET 6 is included in the latest release of Visual Studio 2022 and is automatically installed and configured for you when you install Visual Studio.

Visual Studio dialog for selecting the type of an ASP.NET Core Web Application with API option selected.

Figure 4-37. Selecting ASP.NET CORE 6.0 and Web API project type

Notice Docker support is not enabled now. You'll do that in the next step after the project creation. You'll also notice that by default controller option is checked. You can uncheck that if you want to Create a minimal web API with ASP.NET Core.

To show you can "Dockerize" your project at any time, you'll add Docker support now. So right-click on the project node in Solution Explorer and select Add > Docker support on the context menu.

Context menu option to add Docker support to an existing project: Right-click (on the project) > Add > Docker Support.

Figure 4-38. Adding Docker support to an existing project

To complete adding Docker support, you can choose Windows or Linux. In this case, select Linux.

Option dialog to select Target OS for Dockerfile.

Figure 4-39. Selecting Linux containers.

With these simple steps, you have your ASP.NET Core 6.0 application running on a Linux container.

In a similar way, you can also add a very simple WebApp project (Figure 4-40) to consume the web API endpoint, although the details can be seen in the code repo.

After that, you add orchestrator support for your WebApi project as shown next, in image 4-40.

Adding orchestrator support to WebApi project

Figure 4-40. Adding orchestrator support to WebApi project.

When you choose the Docker Compose option, which is fine for local development, Visual Studio adds the docker-compose project, with the docker-compose files as shown in image 4-41.

Docker-compose added to solution

Figure 4-41. Adding orchestrator support to WebApi project.

The initial files added are similar to these ones:

docker-compose.yml

yml
version: "3.4"

services:
  webapi:
    image: ${DOCKER_REGISTRY-}webapi
    build:
      context: .
      dockerfile: WebApi/Dockerfile

  webapp:
    image: ${DOCKER_REGISTRY-}webapp
    build:
      context: .
      dockerfile: WebApp/Dockerfile

docker-compose.override.yml

yml
version: "3.4"

services:
  webapi:
    environment:
      - ASPNETCORE_ENVIRONMENT=Development
      - ASPNETCORE_URLS=https://+:443;http://+:80
    ports:
      - "80"
      - "443"
    volumes:
      - ${APPDATA}/Microsoft/UserSecrets:/root/.microsoft/usersecrets:ro
      - ${APPDATA}/ASP.NET/Https:/root/.aspnet/https:ro
  webapp:
    environment:
      - ASPNETCORE_ENVIRONMENT=Development
      - ASPNETCORE_URLS=https://+:443;http://+:80
    ports:
      - "80"
      - "443"
    volumes:
      - ${APPDATA}/Microsoft/UserSecrets:/root/.microsoft/usersecrets:ro
      - ${APPDATA}/ASP.NET/Https:/root/.aspnet/https:ro

To run your app with Docker Compose, you just have to make a few tweaks to docker-compose.override.yml.

yml
services:
  webapi:
    #...
    ports:
      - "51080:80"
      - "51443:443"
    #...
  webapp:
    environment:
      #...
      - WebApiBaseAddress=http://webapi
    ports:
      - "50080:80"
      - "50443:443"
    #...

Now you can run your application with the F5 key, or by using the Play button, or the Ctrl+F5 key, selecting the docker-compose project, as shown in image 4-42.

Running docker-compose project with Visual Studio

Figure 4-42. Adding orchestrator support to WebApi project.

When running the docker-compose application as explained, you get:

  1. The images built and containers created as per the docker-compose file.
  2. The browser open in the address configured in the "Properties" dialog for the docker-compose project.
  3. The Container window open (in Visual Studio 2022 version 17.0 and later).
  4. Debugger support for all projects in the solution, as shown in the following images.

Browser opened:

Browser view with web app running

Figure 4-43. Browser window with an application running on multiple containers.

Containers window:

Visual Studio "Containers" window

Figure 4-44. Visual Studio "Containers" window

The Containers window lets you view running containers, browse available images, view environment variables, logs, and port mappings, inspect the filesystem, attach a debugger, or open a terminal window inside the container environment.

As you can see, the integration between Visual Studio 2022 and Docker is completely oriented to the developer's productivity.

Of course, you can also list the images using the docker images command. You should see the webapi and webapp images with the dev tags created by the automatic deployment of our project with Visual Studio 2022.

Console
docker images

Console output from the docker images command, shows a list with: Repository, Tag, Image ID, Created (date), and Size.

Figure 4-45. View of Docker images

Register the Solution in an Azure Container Registry (ACR)

You can upload the images to the Azure Container Registry (ACR), but you could also use Docker Hub or any other registry, so the images can be deployed to the AKS cluster from that registry.

Create an ACR instance

Run the following command from the az cli:

Console
az acr create --name exploredocker --resource-group explore-docker-aks-rg --sku basic --admin-enabled

 Note

The container registry name (for example, exploredocker) must be unique within Azure and contain 5-50 alphanumeric characters. For more details, see Create a container registry.

Create the image in Release mode

You'll now create the image in Release mode (ready for production) by changing to Release, as shown in Figure 4-46, and running the application as you did before.

Toolbar option in VS to build in release mode.

Figure 4-46. Selecting Release Mode

If you execute the docker images command, you'll see both images created, one for debug (dev) and the other for release (latest) mode.

Create a new Tag for the Image

Each container image needs to be tagged with the loginServer name of the registry. This tag is used for routing when pushing container images to an image registry.

You can view the loginServer name from the Azure portal, taking the information from the Azure Container Registry

Browser view of the Azure container registry name, on the top right.

Figure 4-47. View of the name of the Registry

Or by running the following command:

Console
az acr list --resource-group <resource-group-name> --query "[].{acrLoginServer:loginServer}" --output table

Console output from the above command.

Figure 4-48. Get the name of the registry using az cli

In both cases, you'll obtain the name. In our example, exploredocker.azurecr.io.

Now you can tag the image, taking the latest image (the Release image), with the command:

Console
docker tag <image-name>:latest <login-server-name>/<image-name>:v1

After running the docker tag command, list the images with the docker images command, and you should see the image with the new tag.

Console output from the docker images command.

Figure 4-49. View of tagged images

Push the image into the Azure ACR

Log in to the Azure Container Registry

Console
az acr login --name exploredocker

Push the image into the Azure ACR, using the following command:

Console
docker push <login-server-name>/<image-name>:v1

This command takes a while uploading the images but gives you feedback in the process. In the following image, you can see the output from one image completed and another in progress.

Console output from the docker push command.

Figure 4-50. Console output from the push command.

To deploy your multi-container app into your AKS cluster you need some manifest .yaml files that have, most of the properties taken from the docker-compose.yml and docker-compose.override.yml files.

deploy-webapi.yml

yml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: webapi
  labels:
    app: weather-forecast
spec:
  replicas: 1
  selector:
    matchLabels:
      service: webapi
  template:
    metadata:
      labels:
        app: weather-forecast
        service: webapi
    spec:
      containers:
        - name: webapi
          image: exploredocker.azurecr.io/webapi:v1
          imagePullPolicy: IfNotPresent
          ports:
            - containerPort: 80
              protocol: TCP
          env:
            - name: ASPNETCORE_URLS
              value: http://+:80
---
apiVersion: v1
kind: Service
metadata:
  name: webapi
  labels:
    app: weather-forecast
    service: webapi
spec:
  ports:
    - port: 80
      targetPort: 80
      protocol: TCP
  selector:
    service: webapi

deploy-webapp.yml

yml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: webapp
  labels:
    app: weather-forecast
spec:
  replicas: 1
  selector:
    matchLabels:
      service: webapp
  template:
    metadata:
      labels:
        app: weather-forecast
        service: webapp
    spec:
      containers:
        - name: webapp
          image: exploredocker.azurecr.io/webapp:v1
          imagePullPolicy: IfNotPresent
          ports:
            - containerPort: 80
              protocol: TCP
          env:
            - name: ASPNETCORE_URLS
              value: http://+:80
            - name: WebApiBaseAddress
              value: http://webapi
---
apiVersion: v1
kind: Service
metadata:
  name: webapp
  labels:
    app: weather-forecast
    service: webapp
spec:
  type: LoadBalancer
  ports:
    - port: 80
      targetPort: 80
      protocol: TCP
  selector:
    service: webapp

 Note

The previous .yml files only enable the HTTP ports, using the ASPNETCORE_URLS parameter, to avoid issues with the missing certificate in the sample app.

 Tip

You can see how to create the AKS Cluster for this sample in section Deploy to Azure Kubernetes Service (AKS) on this guide.

Now you're almost ready to deploy using kubectl, but first you must get the credentials from the AKS Cluster with this command:

Console
az aks get-credentials --resource-group explore-docker-aks-rg --name explore-docker-aks

Console output from the above command: Merged "explore-docker-aks" as current context in C:\Users\Miguel.kube\config

Figure 4-51. Getting credentials from AKS into the kubectl environment.

You also have to allow the AKS cluster to pull images from the ACR, using this command:

Console
az aks update --name explore-docker-aks --resource-group explore-docker-aks-rg --attach-acr exploredocker

The previous command might take a couple of minutes to complete. Then, use the kubectl apply command to launch the deployments, and then kubectl get all to list the cluster objects.

Console
kubectl apply -f deploy-webapi.yml
kubectl apply -f deploy-webapp.yml

kubectl get all

Console output from the above commands: deployments applied. services created.

Figure 4-52. Deployment to Kubernetes

You'll have to wait a while until the load balancer gets the external IP, checking with kubectl get services, and then the application should be available at that address, as shown in the next image:

Browser view of the application deployed to AKS

Figure 4-53. Deployment to Kubernetes

When the deployment completes, you can access the Kubernetes Web UI with a local proxy, using an ssh tunnel.

First you must create a ClusterRoleBinding with the following command:

Console
kubectl create clusterrolebinding kubernetes-dashboard --clusterrole=cluster-admin --serviceaccount=kube-system:kubernetes-dashboard

And then this command to start the proxy:

Console
az aks browse --resource-group exploredocker-aks-rg --name explore-docker-aks

A browser window should open at http://127.0.0.1:8001 with a view similar to this one:

Browser view of the Kubernetes dashboard, showing Deployments, Pods, Replica Sets, and Services.

Figure 4-54. View Kubernetes cluster information

Now you have your ASP.NET Core application, running in Linux containers, and deployed to an AKS cluster on Azure.

标签:Core,ASP,orchestrator,name,Figure,--,image,project,docker
From: https://www.cnblogs.com/bruce1992/p/17767366.html

相关文章

  • ASP.NET Core Minimal API之optional route parameter with default value and option
    publicstaticvoidMain(string[]args){varbuilder=WebApplication.CreateBuilder(args);varapp=builder.Build();app.MapGet("/product/{name}",(stringname)=>$"Theproductis{name}").WithName("product&......
  • Secure Code Warrior Introduction to OWASP Top 10 Awareness (with latest updates
    MissingFunctionAccessControlAccesstothesefunctionalitiesshouldberestrictedtoauthenticatedusers.However,thecurrentmechanismonlycheckswhetherauserexists.Anyuser,authenticatedornot,willbeabletoaccessrestrictedinformation.U......
  • .NET CORE 之 gRPC使用
    gRPC简单介绍gRPC是一种与语言无关的高性能远程过程调用(RPC)框架(google开源的rpc框架)。gRPC默认使用protocolbuffers,这是Google开源的一套成熟的结构数据序列化机制(也可以使用其他数据格式如JSON) gRPC的主要优点是: HTTP2传输现代高性能轻量级RPC框架。协定......
  • 交叉验证 cross_val_score 获得多个度量值
    默认的,cross_val_score只能计算一个类型的分数,要想获得多个度量值,可用函数cross_validate >>>fromsklearn.model_selectionimportcross_validate>>>fromsklearn.metricsimportrecall_score>>>scoring=['precision_macro','recall_macro�......
  • ASP.NET Core使用Hangfire定时发布文章
    ASP.NETCore使用Hangfire实现定时任务前言也是上了5天班,终于迎来了休息,抽空更新下博客,然后就是下周一公司会对我进行考核,希望考核能通过吧!!!然后我想给博客添加一个定时发布文章的功能,其实这个功能对于我的博客是没什么作用的,什么时候发都没什么人看。但是咱还是要有这个功能。......
  • asp.net 分片下载
    参考:https://learn.microsoft.com/en-us/answers/questions/726990/serving-video-file-stream-from-asp-net-core-6-minihttps://khalidabuhakmeh.com/partial-range-http-requests-with-aspnet-core HTTPRangeRequestsandPartialResponsesWithASP.NETCoreLongg......
  • sprintf、snprintf、vsprintf、asprintf、vasprintf函数
    1.sprintfexternintsprintf(char*__restrict__s,constchar*__restrict__format,...);2.snprintf/*MaximumcharsofoutputtowriteinMAXLEN.*/externintsnprintf(char*__restrict__s,size_t__maxlen,......
  • 无涯教程-ASP.NET MVC - 单元测试
    在计算机编程中,单元测试是一种软件测试方法,通过该方法可以测试源代码的各个单元以确定它们是否适合使用。换句话说,这是一个软件开发过程,其中应用程序的最小可测试部分(称为单元)被单独且独立地检查以确保其正常运行。单元测试通常是自动化的,但也可以手动完成。单元测试的目标......
  • docker 部署.net core ,用于博主本人笔记
     安装dockerdocker部署netcore步骤1、下载最新netcore支持dockerpullmcr.microsoft.com/dotnet/core/aspnet:latest2、发布netcore项目linux环境需要在发布文件夹内创建Dockerfile,并添加如下内容--------------------------以下为dockerFile内容--------------------......
  • 无涯教程-ASP.NET MVC - 模型绑定
    ASP.NETMVC模型绑定允许您将HTTP请求数据与模型进行映射,使用浏览器在HTTP请求中发送的数据创建.NET对象的过程。模型绑定是HTTP请求和C#操作方法之间精心设计的桥梁,由于POST和GET会自动传输到您指定的数据模型中,因此开发人员可以轻松使用表单上的数据,ASP.NETMVC使用默认联编......