本文将为您提供关于kind搭建k8s集群中部署AspNetCore应用的详细介绍，我们还将为您解释k8s搭建的相关知识，同时，我们还将为您提供关于.NetCore2.1秒杀项目一步步实现CI/CD(C

本文将为您提供关于kind搭建k8s集群中部署AspNetCore应用的详细介绍，我们还将为您解释k8s 搭建的相关知识，同时，我们还将为您提供关于.Net Core2.1 秒杀项目一步步实现CI/CD(Centos7.2)系列二:k8s高可用集群搭建总结以及部署API到k8s、ASP.NET Core on K8S 学习初探（3）部署 API 到 K8S、ASP.NET Core on K8S学习初探（3）部署API到K8S、ASP.NET Core on K8S深入学习（1）K8S基础知识与集群搭建的实用信息。

• kind搭建k8s集群中部署AspNetCore应用（k8s 搭建）
• .Net Core2.1 秒杀项目一步步实现CI/CD(Centos7.2)系列二:k8s高可用集群搭建总结以及部署API到k8s
• ASP.NET Core on K8S 学习初探（3）部署 API 到 K8S
• ASP.NET Core on K8S学习初探（3）部署API到K8S
• ASP.NET Core on K8S深入学习（1）K8S基础知识与集群搭建

kind搭建k8s集群中部署AspNetCore应用（k8s 搭建）

前面使用kind快速搭建本地k8s集群 介绍了使用kind搭建k8s集群，这节介绍使用kind搭建的k8s集群中部署.net core 的api应用程序。

1. 准备AspNetCore WebApi项目

项目结构如下：

添加一个Controller,返回当前其中一个IP:

namespace WebApiK8S.Test.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class TestController : ControllerBase
    {
        public string Get()
        {
            var hostName = Dns.GetHostName();
            var hostIP = Dns.GetHostEntry(hostName).AddressList;
            return hostIP[0].ToString();
        }
    }
}

编写Dockerfile:

FROM mcr.microsoft.com/dotnet/aspnet:5.0 AS base
workdir /app
EXPOSE 80

copY . .
ENTRYPOINT ["dotnet", "WebApiK8S.Test.dll"]

#指定基础镜像
FROM mcr.microsoft.com/dotnet/core/aspnet:3.1-buster-slim AS base

#配置工作目录 相当于cd
workdir /app
  
#暴露容器端口，此端口与程序运行路径一致，可
EXPOSE 5000

#复制文件到工作目录
copY . .
 
#ENV ：配置系统环境变量，比如程序环境环境等在这里配置（开发、预发、线上环境）
#这里是配置程序运行端口，如果程序不使用默认的80端口这里一定要设置（程序运行端口）
ENV ASPNETCORE_URLS http://+:5000

#设置时间为中国上海，默认为UTC时间
ENV TZ=Asia/Shanghai
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone

#启动程序
ENTRYPOINT ["dotnet", "AspNetCoreDeployInK8S.dll"]

2、制作镜像

项目编译后拖到Centos系统中

制作镜像

cd /home/website/WebApiK8S.Test/

docker build -t webapik8stest .

3、编写发布应用的demoDeployment.yaml

apiVersion: apps/v1
kind: Deployment
Metadata:
  name: k8s-demo-deployment
  labels:
    k8s-app: k8s-demo-web
spec:
  replicas: 2
  selector:
    matchLabels:
      k8s-app: k8s-demo-web
  template:
    Metadata:
      labels:
        k8s-app: k8s-demo-web
    spec:
      containers:
      - name: k8s-demo
        image: webapik8stest
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 80
---
kind: Service
apiVersion: v1
Metadata:
  labels:
    k8s-app: k8s-demo-web
  name: k8s-demo-service
spec:
  type: NodePort
  ports:
  - port: 80
    targetPort: 80
    name: http
    nodePort: 30000
  selector:
    k8s-app: k8s-demo-web

4. 新建K8s集群，暴露80、443、30000端口

用kind创建K8s时，是相当在本地运行了一个容器，而K8s Cluster就运行在这个容器中。

所以，如果想从外部访问kind K8s的话，就需要把这个容器的端口(K8s的端口)暴露出来。

为了下一步测试，我们重新创建一个新的K8s cluster并且把80、443、30000端口暴露出来。

运行下列命令删除现在的k8s cluster

kind delete cluster --name tsk8s

运行下列命令创建新的k8s cluster

cat <<EOF | kind create cluster --name tsk8s --config=-
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
  kubeadmConfigPatches:
  - |
    kind: InitConfiguration
    nodeRegistration:
      kubeletExtraArgs:
        node-labels: "ingress-ready=true"
  extraPortMappings:
  - containerPort: 80
    hostPort: 80
    protocol: TCP
  - containerPort: 443
    hostPort: 443
    protocol: TCP
  - containerPort: 30000
    hostPort: 30000
    protocol: TCP
EOF

说明：

• extraPortMappings：把K8s容器（相当于K8s所在的服务器）端口暴露出来，这里暴露了80、443、30000
• node-labels：只允许Ingress controller运行在有"ingress-ready=true"标签的node上

运行结果

这时可以看到80、443、30000端口已经暴露出来了

 注意：如果是在公司代理环境下，我们要在K8s容器中设置代理，才可以正常进行下面的测试，设置代理请参考上一篇文章《代理环境下在WSL2中用Kind创建Kubernetes集群》”

5. 添加镜像

 不能直接使用主机上的镜像，需要导入到kind的节点（容器中）

kind load docker-image webapik8stest --name tsk8s

说明：

• webapik8stest：创建的镜像名
• tsk8s：创建的集群名

6. 创建deployment

将demoDeployment.yaml文件拖到Centos系统中

 创建deployment并查看pod，svc状态：

kubectl create -f  demoDeployment.yaml
kubectl get svc,pod -o wide

从上图可以看到对外暴露pod的端口为30000，且该api运行了两个副本。

7、在浏览器访问api

http://192.168.192.140:332/api/test

 http://192.168.192.140:30000/WeatherForecast

curl  http://192.168.192.140:30000/WeatherForecast

访问成功，证明我们的aspnetcore应用成功部署在K8S上！

鸣谢：

https://blog.csdn.net/weixin_42758299/article/details/120908185

https://www.cnblogs.com/roluodev/p/13824191.html

.Net Core2.1 秒杀项目一步步实现CI/CD(Centos7.2)系列二:k8s高可用集群搭建总结以及部署API到k8s

前言：本系列博客又更新了，是博主研究很长时间，亲自动手实践过后的心得，k8s集群是购买了5台阿里云服务器部署的，这个集群差不多搞了一周时间，关于k8s的知识点，我也是刚入门，这方面的知识建议参考博客园大神edisonchou的系列文章《.NET Core on K8S学习实践系列文章索引(Draft版)》，为什么我要写该系列的文章，是因为我之前 工作的几家公司应用都已经容器化了，.net framework 应用也在慢慢迁移到.net core 上，.net core 从1.0就开始使用了，作为开发人员，有些细节上的东西对开发人员是封闭的，我们只知道项目开发完成通过Jenkins构建，构建完成把镜像推送到HarBor，然后在禅道上建个发布任务，贴上镜像的地址，发给运维就好了。我就对这个过程很好奇，业余时间也在研究这方面的东西。好了，暂且聊到这里，下面我就分享一下自己在搭建k8s集群的心得，有说的不对的地方还请纠正。

一、k8s高可用集群搭建总结

我们都知道Kubernetes自身，侧重稳定性、可扩展性、安全性；核心策略的变化小；周边生态持续爆发。k8s搭建的方式有三种：（1）社区方案：杂乱、不可靠、升级难（2）kubeadm：优雅、简单、支持高可用、升级方便、不易维护、文档不够细致 （3）二进制部署，建议初学者使用二进制搭建，因为可以快速放弃，哈哈哈，玩笑归玩笑，二进制的方式易于维护、灵活、升级方便。我的k8s集群使用的是二进制搭建的，5台阿里云的配置 如下：

环境参数：k8s 1.14.0  Docker 17.03.1-ce  Harbor 1.6.0  Jenkins v2.150.2，一定 要注意版本问题，

注意：使用云服务器的，跳过keepalived的配置，不要用虚拟ip（云环境一般都不支持自己定义虚拟ip）就直接把虚拟ip设置为第一个master的ip就可以了。

 PS：如果是一定要高可用的话可以购买云商的负载均衡服务（比如阿里云的SLB），把backends设置成你的三个master节点，然后虚拟ip就配置成负载均衡的内网ip即可。

具体的集群搭建细节，我就不列出来了，因为不是重点。

二、部署WebAPI到k8s

• 准备Deployment YAML

这个YAML文件，引用自Edison Zhou（https://www.cnblogs.com/edisonchou/p/aspnet_core_on_k8s_firststudy_part3.html），在这里我们使用了Edison Zhou的镜像仓库 

apiVersion: apps/v1
kind: Deployment
metadata:
  name: k8s-demo
  namespace: aspnetcore
  labels:
    name: k8s-demo
spec:
  replicas: 2
  selector:
    matchLabels:
      name: k8s-demo
  template:
    metadata:
      labels:
        name: k8s-demo
    spec:
      containers:
      - name: k8s-demo
        image: edisonsaonian/k8s-demo
        ports:
        - containerPort: 80
        imagePullPolicy: Always

---

kind: Service
apiVersion: v1
metadata:
  name: k8s-demo
  namespace: aspnetcore
spec:
  type: NodePort
  ports:
    - port: 80
      targetPort: 80
  selector:
    name: k8s-demo

这里这个deploy.yaml就会告诉K8S关于你的API的所有信息，以及通过什么样的方式暴露出来让外部访问。

　　需要注意的是，这里我们提前为要部署的ASP.NET Core WebAPI项目创建了一个namespace，叫做aspnetcore，因此这里写的namespace : aspnetcore。

　　K8S中通过标签来区分不同的服务，因此这里统一name写成了k8s-demo。

　　在多实例的配置上，通过replicas : 2这个设置告诉K8S给我启动2个实例起来，当然你可以写更大的一个数量值。

　　最后，在spec中告诉K8S我要通过NodePort的方式暴露出来公开访问，因此端口范围从上一篇可以知道，应该是 30000-32767这个范围之内。

• 通过kubectl 部署到k8s

需要先后执行以下命令：

kubectl create namespace aspnetcore // 创建一个命名空间“aspnetcore”

mkdir aspnetcore

cd aspnetcore/
vim deploy.yaml  //将上面的配置写入该文件中
kubectl create -f deploy.yaml

[root@m7-a2-15-43 aspnetcore]# kubectl get svc -n aspnetcore
NAME       TYPE       CLUSTER-IP       EXTERNAL-IP   PORT(S)       AGE
k8s-demo   NodePort   10.254.180.117   <none>        80:8671/TCP   4h55m

可以看到在命名空间aspnetcore下，就有一个k8s-demo的服务运行起来了，并通过端口号8671向外提供访问。

• 验证WebAPI是否可以访问

首先，在浏览器中访问API接口，看看是否能正常访问：http://公网IP:8671/api/values

然后，我们再到Dashboard中，看看k8s-demo的状态：

我们点击命名空间，选择：aspnetcore

当然了，你也可以直接点击：“集群”选项下面的“命名空间”，点击对应的名称，里面可以看到详细的信息。从Dashboard中可以看到更为详细的信息，包括运行的Deployment、容器组（由于我们设置的replicas=2，因此会有2个容器运行起来）、副本集等等，也可以通过Dashboard实时初步地监控我们的API的运行情况。

• 通过Dashboard伸缩WebAPI

在Dashboard中，我们可以可视化地对我们的Deployment进行容器实例的伸缩，具体操作可以参考：https://www.cnblogs.com/edisonchou/p/aspnet_core_on_k8s_firststudy_part3.html，这里我就不再多说了。

 三、总结

本文，简单总结了一下使用阿里云部署高可用k8s集群，可能有同学说怎么不详细写一下部署的过程呢？由于时间仓促，部署的过程文档还在整理中，况且，部署的过程和该系列文章的主题不符，大家可以参考其他文章，关于Dashboard，一般企业内部是不会使用的，都是自研的，只需要了解即可。该篇文章的目的，是 想让大家体验一下所谓的容器编排，以及asp.net core on k8s。笔者也是刚接触，有很多东西需要学习，这只是k8s的一点点，因为还没用到生产 环境，需要观察一段时间，后期，我把部署的过程整理一下，再分享给大家。提前预告一下篇博客的主题：Jenkins+k8s，实现CI/CD，敬请期待。

这是该系类博客要使用的项目：https://github.com/guozheng007/asp.net-core2.1-miaosha-project

参考资料：

Edison Zhou：https://www.cnblogs.com/edisonchou/p/aspnet_core_on_k8s_firststudy_part3.html

刘果国：https://coding.imooc.com/class/335.html（付费课程366.00）

原文出处：https://www.cnblogs.com/runningsmallguo/p/11345620.html

ASP.NET Core on K8S 学习初探（3）部署 API 到 K8S

本篇已加入《.NET Core on K8S 学习实践系列文章索引》，可以点击查看更多容器化技术相关系列文章。

在上一篇《基本概念快速一览》中，我们把基本的一些概念快速地简单地不求甚解地过了一下，本篇开始我们会将 ASP.NET Core WebAPI 部署到 K8S，从而结束初探的旅程。

Section 1 - ASP.NET Core on K8S 学习初探（1）K8S 单节点环境搭建

Section 2 - ASP.NET Core on K8S 学习初探（2）K8S 基本概念快速一览

Section 3 - ASP.NET Core on K8S 学习初探（3）部署 API 到 K8S

一、准备一个 WebAPI

　　这里准备一个空的 ASP.NET Core WebAPI 项目，使用默认自带的 ValuesController 控制器，具体代码见这里。

　　Dockerfile 如下：

FROM microsoft/dotnet:2.1-aspnetcore-runtime AS base
WORKDIR /app
EXPOSE 80

FROM microsoft/dotnet:2.1-sdk AS build
WORKDIR /src
COPY . .

RUN dotnet restore
RUN dotnet build -c Release -o /app

FROM build AS publish
RUN dotnet publish -c Release -o /app

FROM base AS final
WORKDIR /app
COPY --from=publish /app .
ENTRYPOINT ["dotnet", "EDC.K8S.Demo.WebApi.dll"]

　　我们可以事先在自己的 Docker 环境构建这样的一个镜像，看看能否正常使用。

　　由于后面会使用到这个镜像，因此可以将此镜像 push 到 Docker Hub 上。

docker push your-image-name:tagname

　　当然你也可以直接使用我上传的这个镜像（edisonsaonian/k8s-demo）。

二、部署 WebAPI 到 K8S

2.1 准备 Deployment YAML

　　在上一篇中我们知道 Deployment 主要负责 Pod 的编排，那么我们这里就通过一个 YAML 来创建一个 Deployment。

apiVersion: apps/v1
kind: Deployment
metadata:
  name: k8s-demo
  namespace: aspnetcore
  labels:
    name: k8s-demo
spec:
  replicas: 2
  selector:
    matchLabels:
      name: k8s-demo
  template:
    metadata:
      labels:
        name: k8s-demo
    spec:
      containers:
      - name: k8s-demo
        image: edisonsaonian/k8s-demo
        ports:
        - containerPort: 80
        imagePullPolicy: Always

---

kind: Service
apiVersion: v1
metadata:
  name: k8s-demo
  namespace: aspnetcore
spec:
  type: NodePort
  ports:
    - port: 80
      targetPort: 80
  selector:
    name: k8s-demo

　　这里这个 deploy.yaml 就会告诉 K8S 关于你的 API 的所有信息，以及通过什么样的方式暴露出来让外部访问。

　　需要注意的是，这里我们提前为要部署的 ASP.NET Core WebAPI 项目创建了一个 namespace，叫做 aspnetcore，因此这里写的 namespace : aspnetcore。

　　K8S 中通过标签来区分不同的服务，因此这里统一 name 写成了 k8s-demo。

　　在多实例的配置上，通过 replicas : 2 这个设置告诉 K8S 给我启动 2 个实例起来，当然你可以写更大的一个数量值。

　　最后，在 spec 中告诉 K8S 我要通过 NodePort 的方式暴露出来公开访问，因此端口范围从上一篇可以知道，应该是 30000-32767 这个范围之内。

2.2 通过 kubectl 部署到 K8S

　　首先，确保你的 Docker for Windows 以及 Kubernetes 都启动起来了。

　　然后，在 Powershell 中通过 kubectl 完成 API 的部署，只需要下面这一句命令行即可：

kubectl create -f deploy.yaml

　　看到上面的提示 "service created"，就可以知道已经创建好了，这里我们再通过下面这个命令来验证一下：

kubectl get svc -n aspnetcore

　　可以看到，在命名空间 aspnetcore 下，就有了一个 k8s-demo 的服务运行起来了，并通过端口号 31435 向外部提供访问。

2.3 在 K8S 中验证 WebAPI

　　首先，我们可以通过浏览器来访问一下这个 API 接口，看看是否能正常访问到。

• /api/values

• /api/values/1000

　　其次，还记得在第一篇中部署的 Dashboard 吗？我们通过 Dashboard 来看看我们的 k8s-demo 的状态：

　　从 Dashboard 中可以看到更为详细的信息，包括运行的 Deployment、容器组（由于我们设置的 replicas=2，因此会有 2 个容器运行起来）、副本集等等，也可以通过 Dashboard 实时初步地监控我们的 API 的运行情况。

三、在 K8S 中对 WebAPI 的伸缩

3.1 通过 Dashboard 伸缩 WebAPI

　　在 Dashboard 中，我们可以可视化地对我们的 Deployment 进行容器实例的伸缩，如下图所示：

　　在弹出的伸缩选项对话框中输入个数，例如我们这里从 2 个缩减为 1 个，然后确定。

　　再次观看 Dashboard，可以看到已经从原来的 2 个容器实例变为 1 个了。

3.2 通过 Kubectl 伸缩 WebAPI

　　除了在 Dashboard 中可视化地操作进行伸缩，也可以通过 kubectl 来进行，例如下面这句命令，将容器实例扩展到 3 个。需要注意的是，由于我们的 k8s-demo 所在的命名空间是在 aspnetcore 下，因此也需要指明 --namespace=aspnetcore。

kubectl scale deployment k8s-demo --replicas=3 --namespace=aspnetcore

　　再到 Dashboard 中来验证一下，是否扩展到了 3 个容器实例：

3.2 自动伸缩 WebAPI 实例

　　在 K8S 中，提供了一个 autoscale 接口来实现服务的自动伸缩，它会采用默认的自动伸缩策略（例如根据 CPU 的负载情况）来帮助我们实现弹性伸缩的功能。例如下面这句命令可以实现我们的 k8s-demo 可以伸缩的范围是 1~3 个，根据负载情况自己伸缩，在没有多少请求量压力很小时收缩为一个，在压力较大时启动另一个实例来降低负载。

kubectl autoscale deployment k8s-demo --min=1 --max=3 --namespace=aspnetcore

四、补充知识点

4.1 常用 Kubectl 命令

kubectl get svc -n kube-system  //获取指定命名空间的服务
kubectl cluster-info // 获取集群信息
kubectl get nodes // 获取集群节点信息
kubectl delete node 192.168.2.152  //删除节点 192.168.2.152
kubectl get namespaces // 获取所有命名空间
kubectl create namespace aspnetcore // 创建一个命名空间“aspnetcore”

　　更多 kubectl 命令参考：

　　（1）https://jimmysong.io/kubernetes-handbook/guide/kubectl-cheatsheet.html

　　（2）https://www.jianshu.com/p/fb5c0d115421

4.2 YAML 文件解析

 　　关于 YAML 文件各个节点的解释，可以通过下面这个命令去了解：

kubectl explain deployment.metadata

　　更多 YAML 文件的节点参考：https://www.kubernetes.org.cn/1414.html

4.3 更多 K8S 基础知识？

　　推荐阅读《18 张插画了解 Kubernetes 背景与概念》

五、小结

　　本文简单的介绍了一下在 Docker for Windows 环境下，通过 kubectl 部署一个 ASP.NET Core WebAPI 到 K8S 中，并初步使用了 K8S 的伸缩特性对 Deployment 进行实例的伸缩，体验了一下所谓的容器的编排。当然，笔者也是初玩，有很多还没学习，这也只是 K8S 的冰山一角，后续我会学习在 Linux 下部署 K8S 的生产级集群环境，深入学习 K8S 的各种概念并实践，最后会学习阿里云 ACK 服务（容器服务 Kubernetes 版）或腾讯云 TKE 服务（基于 Kubernetes 的容器服务）去部署和实践公司的生产环境，相信到时也会有很多的分享的！

参考资料

• Jesse，http://video.jessetalk.cn/my/course/6
• 阿里云，https://github.com/AliyunContainerService/k8s-for-docker-desktop/tree/18.09
• 阿里云，https://yq.aliyun.com/articles/508460?spm=a2c4e.11153940.blogcont221687.18.7dd57733hFolMo
• 圣杰，https://www.cnblogs.com/sheng-jie/p/10591794.html
• 忱康，https://blog.csdn.net/cuipengchong/article/details/72459299

原文出处：https://www.cnblogs.com/edisonchou/p/aspnet_core_on_k8s_firststudy_part3.html

ASP.NET Core on K8S学习初探（3）部署API到K8S

引用网址：https://blog.csdn.net/sD7O95O/article/details/95041433

“ 终于可以部署ASP.NET Core到K8S中了...”

在上一篇《基本概念快速一览》中，我们把基本的一些概念快速地简单地不求甚解地过了一下，本篇开始我们会将ASP.NET Core WebAPI部署到K8S，从而结束初探的旅程。

01

—

准备一个WebAPI

    这里准备一个空的ASP.NET Core WebAPI项目，使用默认自带的ValuesController控制器，具体代码见这里（https://github.com/EdisonChou/AspNetCore.On.K8S/tree/master/src/01_hello-k8s/EDC.K8S.Demo.WebApi）。

　　Dockerfile如下：

1.   FROM microsoft/dotnet:2.1-aspnetcore-runtime AS base
2.   workdir /app
3.   EXPOSE 80
4.    
5.   FROM microsoft/dotnet:2.1-sdk AS build
6.   workdir /src
7.   copY . .
8.    
9.   RUN dotnet restore
10.   RUN dotnet build -c Release -o /app
11.    
12.   FROM build AS publish
13.   RUN dotnet publish -c Release -o /app
14.    
15.   FROM base AS final
16.   workdir /app
17.   copY --from=publish /app .
18.   ENTRYPOINT ["dotnet", "EDC.K8S.Demo.WebApi.dll"]

　　我们可以事先在自己的Docker环境构建这样的一个镜像，看看能否正常使用。

　　由于后面会使用到这个镜像，因此可以将此镜像push到Docker Hub上。

docker push your-image-name:tagname

　　当然你也可以直接使用我上传的这个镜像（edisonsaonian/k8s-demo）。

　　

 

 

02

—

部署WebAPI到K8S

 

2.1 准备Deployment YAML

　　在上一篇中我们知道Deployment主要负责Pod的编排，那么我们这里就通过一个YAML来创建一个Deployment。

 

1. apiVersion: apps/v1
2.   kind: Deployment
3.   Metadata:
4.   name: k8s-demo
5.   namespace: aspnetcore
6.   labels:
7.   name: k8s-demo
8.   spec:
9.   replicas: 2
10.   selector:
11.   matchLabels:
12.   name: k8s-demo
13.   template:
14.   Metadata:
15.   labels:
16.   name: k8s-demo
17.   spec:
18.   containers:
19.   - name: k8s-demo
20.   image: edisonsaonian/k8s-demo
21.   ports:
22.   - containerPort: 80
23.   imagePullPolicy: Always
24.    
25.   ---
26.    
27.   kind: Service
28.   apiVersion: v1
29.   Metadata:
30.   name: k8s-demo
31.   namespace: aspnetcore
32.   spec:
33.   type: NodePort
34.   ports:
35.   - port: 80
36.   targetPort: 80
37.   selector:
38.   name: k8s-demo

　　这里这个deploy.yaml就会告诉K8S关于你的API的所有信息，以及通过什么样的方式暴露出来让外部访问。

　　需要注意的是，这里我们提前为要部署的ASP.NET Core WebAPI项目创建了一个namespace，叫做aspnetcore，因此这里写的namespace : aspnetcore。

　　K8S中通过标签来区分不同的服务，因此这里统一name写成了k8s-demo。

　　在多实例的配置上，通过replicas : 2这个设置告诉K8S给我启动2个实例起来，当然你可以写更大的一个数量值。

　　最后，在spec中告诉K8S我要通过NodePort的方式暴露出来公开访问，因此端口范围从上一篇可以知道，应该是 30000-32767这个范围之内。

2.2 通过kubectl部署到K8S

　　首先，确保你的Docker for Windows以及Kubernetes都启动起来了。

　　然后，在Powershell中通过kubectl完成API的部署，只需要下面这一句命令行即可：

kubectl create -f deploy.yaml

　　

　　看到上面的提示"service created"，就可以知道已经创建好了，这里我们再通过下面这个命令来验证一下：

kubectl get svc -n aspnetcore

　　

　　可以看到，在命名空间aspnetcore下，就有了一个k8s-demo的服务运行起来了，并通过端口号31435向外部提供访问。

2.3 在K8S中验证WebAPI

　　首先，我们可以通过浏览器来访问一下这个API接口，看看是否能正常访问到。

　　

　　

　　其次，还记得在第一篇中部署的Dashboard吗？我们通过Dashboard来看看我们的k8s-demo的状态：

　　

　　从Dashboard中可以看到更为详细的信息，包括运行的Deployment、容器组（由于我们设置的replicas=2，因此会有2个容器运行起来）、副本集等等，也可以通过Dashboard实时初步地监控我们的API的运行情况。

 

03

—

在K8S中对WebAPI进行伸缩

 

 

3.1 通过Dashboard伸缩WebAPI

　　在Dashboard中，我们可以可视化地对我们的Deployment进行容器实例的伸缩，如下图所示：

　　

　　在弹出的伸缩选项对话框中输入个数，例如我们这里从2个缩减为1个，然后确定。

　　

　　再次观看Dashboard，可以看到已经从原来的2个容器实例变为1个了。

　　

3.2 通过Kubectl伸缩WebAPI

　　除了在Dashboard中可视化地操作进行伸缩，也可以通过kubectl来进行，例如下面这句命令，将容器实例扩展到3个。需要注意的是，由于我们的k8s-demo所在的命名空间是在aspnetcore下，因此也需要指明--namespace=aspnetcore。

kubectl scale deployment k8s-demo --replicas=3 --namespace=aspnetcore

　　

　　再到Dashboard中来验证一下，是否扩展到了3个容器实例：

　　

3.2 自动伸缩WebAPI实例

　　在K8S中，提供了一个autoscale接口来实现服务的自动伸缩，它会采用默认的自动伸缩策略（例如根据cpu的负载情况）来帮助我们实现弹性伸缩的功能。例如下面这句命令可以实现我们的k8s-demo可以伸缩的范围是1~3个，根据负载情况自己伸缩，在没有多少请求量压力很小时收缩为一个，在压力较大时启动另一个实例来降低负载。

kubectl autoscale deployment k8s-demo --min=1 --max=3 --namespace=aspnetcore

　　

 

 

04

—

一些补充知识点

4.1 常用Kubectl命令

1.   kubectl get svc -n kube-system //获取指定命名空间的服务
2.   kubectl cluster-info // 获取集群信息
3.   kubectl get nodes // 获取集群节点信息
4.   kubectl delete node 192.168.2.152 //删除节点 192.168.2.152
5.   kubectl get namespaces // 获取所有命名空间
6.   kubectl create namespace aspnetcore // 创建一个命名空间“aspnetcore”

　　更多kubectl命令参考：

　　（1）https://jimmysong.io/kubernetes-handbook/guide/kubectl-cheatsheet.html

　　（2）https://www.jianshu.com/p/fb5c0d115421

4.2 YAML文件解析

 　　关于YAML文件各个节点的解释，可以通过下面这个命令去了解：

kubectl explain deployment.Metadata

　　

　　更多YAML文件的节点参考：https://www.kubernetes.org.cn/1414.html

4.3 更多K8S基础知识？

　　推荐阅读《18张插画了解Kubernetes背景与概念》

 　　

 

 

05

—

小结

 

 

        本文简单的介绍了一下在Docker for Windows环境下，通过kubectl部署一个ASP.NET Core WebAPI到K8S中，并初步使用了K8S的伸缩特性对Deployment进行实例的伸缩，体验了一下所谓的容器的编排。当然，笔者也是初玩，有很多还没学习，这也只是K8S的冰山一角，后续我会学习在Linux下部署K8S的生产级集群环境，深入学习K8S的各种概念并实践，最后会学习阿里云ACK服务（容器服务Kubernetes版）或腾讯云TKE服务（基于Kubernetes的容器服务）去部署和实践公司的生产环境，相信到时也会有很多的分享的！

 

References

 

参考资料

 

1. Jesse，http://video.jessetalk.cn/my/course/6

2. 阿里云，https://github.com/AliyunContainerService/k8s-for-docker-desktop/tree/18.09

3. 阿里云，https://yq.aliyun.com/articles/508460?spm=a2c4e.11153940.blogcont221687.18.7dd57733hFolMo

4. 圣杰，https://www.cnblogs.com/sheng-jie/p/10591794.html

5. 忱康，https://blog.csdn.net/cuipengchong/article/details/72459299

6.  

 

ASP.NET Core on K8S深入学习（1）K8S基础知识与集群搭建

本篇已加入《.NET Core on K8S学习实践系列文章索引》，可以点击查看更多容器化技术相关系列文章。

在上一个小系列文章《ASP.NET Core on K8S学习初探》中，通过在Windows上通过Docker for Windows搭建了一个单节点的K8S环境，并初步尝试将ASP.NET Core WebAPI项目部署到了K8S，把玩了一下快速部署和实例伸缩。这个系列开始，会继续学习K8S以及在Linux上搭建集群来深入把玩。本篇会回顾一下K8S的基本概念以及架构组成，然后会通过Kubeadm快速地搭建一个K8S集群供后续学习把玩之用。

一、K8S基础概念回顾

　　1.Cluster 集群

　　计算、存储和网络资源的集合，Kubernetes利用这些资源运行各种基于容器的应用。

　　2.Master

　　Master是Cluster的大脑，负责调度（决定将应用放在哪里运行），一般为了实现高可用，会有多个Master。

　　3.Node

　　负责运行具体的容器，Node由Master管理，它会监控并汇报容器的状态，同时根据Master的要求管理容器的生命周期。

　　eg. 在交互实验中，这个Cluster中只有一个主机，它既是Master也是Node。

　　4.Pod

　　Kubernetes的最小工作单元，每个Pod包含一个或多个容器。Pod中的容器会被作为一个整体被Master调度到一个Node上运行。

　　 （1）为何引入Pod？

　　一是方便管理：

　　有些容器天生联系紧密，需要在一起工作。Pod提供了比容器更高层次的抽象，将它们封装到一个部署单元中。K8S以Pod为最小单位进行调度、扩展、共享资源、管理生命周期。

　　eg.正例：File Puller & Web Server => 需要部署在一起工作

　　　 反例：Tomecat & MySQL => 不需要部署在一起工作

　　二是可以共享资源和通信：

　　Pod中所有容器使用同一个网络namespace，即相同的IP和端口空间，可以直接用localhost通信，而且还可以共享存储（本质是通过将Volume挂载到Pod中的每个容器）

　　 （2）如何使用Pod？

　　运行单个容器：one-container-per-Pod，K8S中最常见的模型，即使这种情形下，K8S管理的也是Pod而不是单个容器。

　　运行多个容器：将联系非常紧密的多个容器部署到一个Pod中，可以直接共享资源。

　　5.Controller

　　K8S不会直接创建Pod，是通过Controller来管理Pod的。为了满足不同业务场景，K8S提供了多种Controller：

　　（1）Deployment

　　最常见的Controller，可以管理Pod的多个副本，并确保Pod按照期望的状态运行。

　　（2）ReplicaSet

　　实现了Pod的多副本管理，使用Deployment时会自动创建ReplicaSet。换句话说，Deployment是通过ReplicaSet来管理Pod的多个副本的，通常不需要直接使用ReplicaSet。

　　（3）DaemonSet

　　用于每个Node最多只运行一个Pod副本的场景，DaemonSet通常用于运行daemon（守护进程、后台程序）。

　　（4）StatefuleSet

　　用于保证Pod的每个副本在整个生命周期中名称是不变的，而其他的Controller不提供这个功能。（非StatefuleSet下，当某个Pod发生故障需要删除并重启时，Pod的名称是会变化的）

　　（5）Job

　　用于运行结束就删除的应用，其他Controller下Pod通常是长期持续运行的。

　　6.Service

　　K8S定义了外界访问一个或一组特定Pod的方式，就是Service。每个Service有自己的IP和端口，并且为Pod提供了负载均衡。

　　如果说K8S运行Pod的任务是交给了Controller去做，那么访问Pod的任务则是交给了Service去做。

　　7.Namespace

　　Namespace将一个物理的Cluster从逻辑上划分为多个虚拟Cluster，每个虚拟Cluster就是一个Namespace，不同Namespace中的资源是完全隔离的。

K8S中会自动创建两个Namespace：

　　（1）default：创建资源时如果不指定Namespace就会放到这里

　　（2）kube-system: K8S自己创建的系统资源都会放到这个Namespace中

二、K8S集群架构解析

　　下面展示了一个最小化的K8S集群，一个master节点和两个node节点：

*.master上也有kubelet和kube-proxy是因为master同时也是一个Node

　　1.Master节点

　　K8S集群的“ 大脑”，运行以下多个Daemon服务：

• API Server（kube-apiserver）
• 提供Restful API => Kubernetes API，供其他组件调用以管理Cluster的各种资源
• Scheduler（kube-scheduler）
• 负责决定将Pod放在哪个Node上Run起来
• 调度时会根据指定算法选择Pod（eg.集群拓扑结构、各节点负载情况、HA等等）
• Controller Manager（kube-controller-manager）
• 负责管理集群中的各种资源，保证资源处于预期的状态
• 由多种Controller组成
• Replication Controller：管理Deployment、StatefuleSet、DaemonSet的生命周期
• Endpoints Controller
• Namespace Controller：管理Namespace资源
• Serviceaccounts Controller
• Etcd
• 负责保存K8S集群中的配置信息和各种资源的状态信息
• 当数据发生变化时，会及时通知K8S相关组件
• Pod网络
• 保证Pod能够相互通信，Flannel是一个可选方案

　　2.Node节点

　　运行Pod的主战场，主要运行以下K8S组件：

• kubelet
• Node的Agent，负责创建运行容器与向Master报告运行状态
• kube-proxy
• 每个Node都会运行proxy，它负责请求转发到后端的容器
• Pod网络
• 保证Pod能够相互通信，Flannel是一个可选方案

三、K8S集群环境搭建

3.1 K8S环境搭建的几种方式

　　搭建K8S环境有几种常见的方式如下：

　　（1）Minikube

　　Minikube是一个工具，可以在本地快速运行一个单点的K8S，供初步尝试K8S或日常开发的用户使用，不能用于生产环境。

　　（2）Kubeadm

　　Kubeadm是K8S官方社区推出的一套用于简化快速部署K8S集群的工具，Kubeadm的设计目的是为新用户开始尝试K8S提供一种简单的方法。

　　（3）二进制包

　　除了以上两种方式外，我们还可以通过从官方下载二进制包，手动部署每个组件组成K8S集群，这也是目前企业生产环境中广为使用的方式，但对K8S管理人员的要求较高。

　　本次学习实践我们主要借助Kubeadm工具搭建K8S集群，以便后续实践部署ASP.NET Core应用集群。

3.2 搭建前的准备工作

　　（1）准备三台Linux服务器

　　这里我选择通过VMware Workstaion来搭建3个虚拟机，每个配置2CPU和2G内存，如下图：

　　

　　（2）配置主机名与静态IP地址如下表所示：

角色 主机名 IP地址 Master k8s-master 192.168.2.100 Node k8s-node1 192.168.2.101 Node k8s-node2 192.168.2.102

　　然后，更改hosts文件添加主机名与IP映射关系

# vim /etc/hosts
192.168.2.100 k8s-master
192.168.2.101 k8s-node1
192.168.2.102 k8s-node2

　　（3）关闭防火墙

systemctl stop firewalld
systemctl disable firewalld

　　（4）关闭selinux

sed -i ''s/enforcing/disabled/'' /etc/selinux/config
setenforce 0

　　（5）关闭swap => K8S中不支持swap分区

# vim /etc/fstab
#/dev/mapper/centos-swap swap                    swap    defaults        0 0

　　*.编辑etc/fstab将swap那一行注释掉或者删除掉

　　（6）将桥接的IPv4流量传递到iptables的链

# cat > /etc/sysctl.d/k8s.conf << EOF
   net.bridge.bridge-nf-call-ip6tables = 1
   net.bridge.bridge-nf-call-iptables = 1
   EOF

# sysctl --system

3.3 安装Docker&Kubeadm&Kubelet

　　以下步骤请在所有节点中都操作：

　　（1）安装Docker

# wget https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo -O
/etc/yum.repos.d/docker-ce.repo
# yum -y install docker-ce-18.06.1.ce-3.el7
# systemctl enable docker && systemctl start docker
# docker --version
Docker version 18.06.1-ce, build e68fc7a

　　*.这里安装的是18.06社区版，如果你之前有安装低版本的Docker，为了配合本次实验的K8S版本（1.13.x），建议先卸载掉，卸载过程可以参考这篇文章《CentOS7 Docker升级》。

　　（2）添加阿里云Yum软件源

# cat > /etc/yum.repos.d/kubernetes.repo << EOF
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg
https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
EOF

　　（3）安装Kubeadm&Kubelet&Kubectl

　　注意：本次部署K8S版本号为1.13.3

# yum install -y kubelet-1.13.3 kubeadm-1.13.3 kubectl-1.13.3
# systemctl enable kubelet

　　遇到的一些坑如下：

　　① 碰到需要kubernetes-cni的问题：

#####错误：软件包：kubelet-1.13.3-0.x86_64 (kubernetes)
需要：kubernetes-cni = 0.6.0
可用: kubernetes-cni-0.3.0.1-0.07a8a2.x86_64 (kubernetes)
kubernetes-cni = 0.3.0.1-0.07a8a2
可用: kubernetes-cni-0.5.1-0.x86_64 (kubernetes)
kubernetes-cni = 0.5.1-0
可用: kubernetes-cni-0.5.1-1.x86_64 (kubernetes)
kubernetes-cni = 0.5.1-1
可用: kubernetes-cni-0.6.0-0.x86_64 (kubernetes)
kubernetes-cni = 0.6.0-0
正在安装: kubernetes-cni-0.7.5-0.x86_64 (kubernetes)
kubernetes-cni = 0.7.5-0
您可以尝试添加 --skip-broken 选项来解决该问题
您可以尝试执行：rpm -Va --nofiles --nodigest

　　解决：手动安装kubernetes-cni对应的版本

yum install -y kubelet-1.13.3 kubeadm-1.13.3 kubectl-1.13.3 kubernetes-cni-0.6.0

　　② 使用yum安装程序时，提示xxx.rpm公钥尚未安装

从 https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg 检索密钥
导入 GPG key 0xA7317B0F:
 用户ID     : "Google Cloud Packages Automatic Signing Key <gc-team@google.com>"
 指纹       : d0bc 747f d8ca f711 7500 d6fa 3746 c208 a731 7b0f
 来自       : https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg

e3438a5f740b3a907758799c3be2512a4b5c64dbe30352b2428788775c6b359e-kubectl-1.13.3-0.x86_64.rpm 的公钥尚未安装

 失败的软件包是：kubectl-1.13.3-0.x86_64
 GPG  密钥配置为：https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg

　　解决：使用 yum install xxx.rpm --nogpgcheck 命令格式跳过公钥检查，比如跳过kubectl和kubeadm的公钥检查如下命令：

yum install kubectl-1.13.3-0.x86_64 --nogpgcheck
yum install kubeadm-1.13.3-0.x86_64 --nogpgcheck

3.4 部署Kubernetes Master

　　以下步骤请在k8s-master节点上操作：

kubeadm init \
--apiserver-advertise-address=192.168.2.100 \
--image-repository registry.aliyuncs.com/google_containers \
--kubernetes-version v1.13.3 \
--service-cidr=10.1.0.0/16 \
--pod-network-cidr=10.244.0.0/16

PS：由于默认拉取镜像地址k8s.gcr.io国内无法访问，这里指定阿里云镜像仓库地址（registry.aliyuncs.com/google_containers）。官方建议服务器至少2CPU+2G内存，当然内存1G也是可以的，但是会出Warning，建议还是老老实实升2G内存把。

　　

　　接下来，为了顺利使用kubectl命令，执行以下命令：

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config
# kubectl get nodes

　　这时你可以使用kubectl了，当你执行完kubectl get nodes之后，你会看到如下状态：

　　

3.5 部署Pod网络插件（CNI）

　　同样，继续在k8s-master上操作：

kubectl apply -f \
https://raw.githubusercontent.com/coreos/flannel/a70459be0084506e4ec919aa1c114638878db11b/Documentation/kube-flannel.yml

　　然后通过以下命令验证：全部为Running则OK，其中一个不为Running，比如：Pending、ImagePullBackOff都表明Pod没有就绪

　　

　　如果其中有的Pod没有Running，可以通过以下命令查看具体错误原因，比如这里我想查看kube-flannel-ds-amd64-8bmbm这个pod的错误信息：

kubectl describe pod kube-flannel-ds-amd64-8bmbm -n kube-system

　　在此过程中可能会遇到无法从qury.io拉取flannel镜像从而导致无法正常Running，解决办法如下：

　　使用国内云服务商提供的镜像源然后通过修改tag的方式曲线救国

docker pull quay-mirror.qiniu.com/coreos/flannel:v0.11.0-amd64
docker tag quay-mirror.qiniu.com/coreos/flannel:v0.11.0-amd64 quay.io/coreos/flannel:v0.10.0-amd64
docker rmi quay-mirror.qiniu.com/coreos/flannell:v0.11.0-amd64

　　这时，我们再看看master节点的状态就会从NotReady变为Ready：

　　

　　那么，恭喜你，Master节点部署结束了。如果你只想要一个单节点的K8S，那么这里就完成了部署了。

3.6 加入Kubernetes Node

　　在两台Node节点上执行join命令：

kubeadm join 192.168.2.100:6443 --token ekqxk2.iiu5wx5bbnbdtxsw --discovery-token-ca-cert-hash \
sha256:c50bb83d04f64f4a714b745f04682b27768c1298f331e697419451f3550f2d05

　　这里需要注意的就是，带上在Master节点Init成功后输出的Token。如果找不到了，没关系，可以通过以下命令来查看：

kubeadm token list

　　Node节点上成功join之后会得到以下信息：

　　

　　这时，我们在master节点上执行以下命令可以看到集群各个节点的状态了：

　　

　　如果看到两个Node状态不是Ready，那么可能需要检查哪些Pod没有正常运行：

kubectl get pod --all-namespaces

　　然后按照3.5中的检查方式进行检查并修复，最终kubectl get nodes效果应该状态都是Running。注意的是在检查时需要注意是哪个Node上的错误，然后在对应的Node进行修复，比如拉取flannel镜像。

　　至此，一个最小化的K8S集群已经搭建完毕。

3.7 测试Kubernetes集群

　　这里为了快速地验证一下我们的K8S集群是否可用，创建一个示例Pod（这里默认是一个副本）：

kubectl create deployment nginx --image=nginx
kubectl expose deployment nginx --port=80 --type=NodePort
kubectl get pod,svc

　　

　　如果想要看到更多的信息，比如pod被部署在了哪个Node上，可以通过 kubectl get pods,svc -o wide来查看。

　　

 　　因为是NodePort方式，因此其映射的端口号会在30000-32767范围内随机取一个，我们可以直接通过浏览器输入IP地址访问，比如这时我们通过浏览器来访问一下任一Node的IP地址加端口号，例如192.168.2.101:31174或192.168.2.102:31174

　　

　　

 　　如果能够成功看到，那么恭喜你，你的K8S集群能够成功运行了，万里长征走完了第一步！

四、小结

　　本文快速地介绍了一下Kubernetes的核心构成组件及其作用，然后通过在三台Linux主机上通过Kubeadm搭建了一个Master节点两个Node节点的集群，最后通过部署一个Deployment来快速地验证了一下集群是否可用。下一篇会通过一个ASP.NET Core的部署例子来演示和介绍一下各个组件之间是如何协作的，以及部署Dashboard。

参考资料

（1）CloudMan，《每天5分钟玩转Kubernetes》

（2）李振良，《一天入门Kubernets教程》

（3）李振良，《30分钟部署一个Kubernetes集群》

（4）cao_xiaobo，《CentOS7 部署K8S集群》

 

出处：https://edisonchou.cnblogs.com

本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文链接。

关于kind搭建k8s集群中部署AspNetCore应用和k8s 搭建的介绍已经告一段落，感谢您的耐心阅读，如果想了解更多关于.Net Core2.1 秒杀项目一步步实现CI/CD(Centos7.2)系列二:k8s高可用集群搭建总结以及部署API到k8s、ASP.NET Core on K8S 学习初探（3）部署 API 到 K8S、ASP.NET Core on K8S学习初探（3）部署API到K8S、ASP.NET Core on K8S深入学习（1）K8S基础知识与集群搭建的相关信息，请在本站寻找。

本文标签：

• k8s集群部署
• AspNetCore应用
• kind搭建
• k8s集群搭建