Kubernetes教程(四)---Service核心原理

Kubernetes 四层负载均衡:Service核心原理与实战指南 API(应用程序编程接口)是不同软件 / 系统间遵循统一规则沟通的 “桥梁”,定义了数据请求与返回的方式,能实现功能复用、降低开发成本且保障交互安全,像餐厅服务员般帮软件间传递需求与结果,无需暴露彼此内部逻辑。 阅读详情

来自:指月 https://www.lixueduan.com

原文:https://www.lixueduan.com/posts/kubernetes/04-service-core/

本文主要讲述了 Kubernetes 中的 Service 的具体实现原理。所谓 Service,其实就是 Kubernetes 为 Pod 分配的、固定的、基于 iptables(或者 IPVS)的访问入口。而这些访问入口代理的 Pod 信息,则来自于 Etcd,由 kube-proxy 通过控制循环来维护。


如果你对云原生技术充满好奇,想要深入了解更多相关的文章和资讯,欢迎关注微信公众号。

扫描下方二维码或搜索公众号【探索云原生】即可订阅


1. 概述

Kubernetes 之所以需要 Service,一方面是因为 Pod 的 IP 不是固定的,另一方面则是因为一组 Pod 实例之间总会有负载均衡的需求。

一个最典型的 Service 定义,如下所示:

apiVersion: v1
kind: Service
metadata:
  name: hostnames
spec:
  selector:
    app: hostnames
  ports:
  - name: default
    protocol: TCP
    port: 80
    targetPort: 9376

spec.selector 字段表明这个 Service 只代理携带了 app=hostnames 标签的 Pod。并且,这个 Service 的 80 端口,代理的是 Pod 的 9376 端口。

然后,我们的应用的 Deployment,如下所示:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hostnames
spec:
  selector:
    matchLabels:
      app: hostnames
  replicas: 3
  template:
    metadata:
      labels:
        app: hostnames
    spec:
      containers:
      - name: hostnames
        image: k8s.gcr.io/serve_hostname
        ports:
        - containerPort: 9376
          protocol: TCP

这个应用的作用,就是每次访问 9376 端口时,返回它自己的 hostname。

而被 selector 选中的 Pod,就称为 Service 的 Endpoints,你可以使用 kubectl get endpoints 命令看到它们,如下所示:

$ kubectl get endpoints hostnames
NAME        ENDPOINTS
hostnames   10.244.0.5:9376,10.244.0.6:9376,10.244.0.7:9376

需要注意的是,只有处于 Running 状态,且 readinessProbe 检查通过的 Pod,才会出现在 Service 的 Endpoints 列表里。并且,当某一个 Pod 出现问题时,Kubernetes 会自动把它从 Service 里摘除掉。

而此时,通过该 Service 的 VIP 地址 10.0.1.175,你就可以访问到它所代理的 Pod 了:

$ kubectl get svc hostnamesNAME        TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGEhostnames   ClusterIP   10.0.1.175   <none>        80/TCP    5s

这个 VIP 地址是 Kubernetes 自动为 Service 分配的。

$ curl 10.0.1.175:80
hostnames-0uton
$ curl 10.0.1.175:80
hostnames-yp2kp
$ curl 10.0.1.175:80
hostnames-bvc05

通过三次连续不断地访问 Service 的 VIP 地址和代理端口 80,它就为我们依次返回了三个 Pod 的 hostname。这也正印证了 Service 提供的是 Round Robin 方式的负载均衡。

对于这种方式,我们称为:ClusterIP 模式的 Service。

2. 原理

实际上,Service 是由 kube-proxy 组件,加上 iptables 来共同实现的。

固定入口

举个例子,对于我们前面创建的名叫 hostnames 的 Service 来说,一旦它被提交给 Kubernetes,那么 kube-proxy 就可以通过 Service 的 Informer 感知到这样一个 Service 对象的添加。而作为对这个事件的响应,它就会在宿主机上创建这样一条 iptables 规则(你可以通过 iptables-save 看到它),如下所示:

-A KUBE-SERVICES -d 10.0.1.175/32 -p tcp -m comment --comment "default/hostnames: cluster IP" -m tcp --dport 80 -j KUBE-SVC-NWV5X2332I4OT4T3

可以看到,这条 iptables 规则的含义是:凡是目的地址是 10.0.1.175、目的端口是 80 的 IP 包,都应该跳转到另外一条名叫 KUBE-SVC-NWV5X2332I4OT4T3 的 iptables 链进行处理。

而我们前面已经看到,10.0.1.175 正是这个 Service 的 VIP。所以这一条规则,就为这个 Service 设置了一个固定的入口地址。

并且,由于 10.0.1.175 只是一条 iptables 规则上的配置,并没有真正的网络设备,所以你 ping 这个地址,是不会有任何响应的。

因为需要指定具体端口时才会匹配上

iptables 链

我们即将跳转到的 KUBE-SVC-NWV5X2332I4OT4T3 规则实际上是一组规则的集合,如下所示:

-A KUBE-SVC-NWV5X2332I4OT4T3 -m comment --comment "default/hostnames:" -m statistic --mode random --probability 0.33332999982 -j KUBE-SEP-WNBA2IHDGP2BOBGZ
-A KUBE-SVC-NWV5X2332I4OT4T3 -m comment --comment "default/hostnames:" -m statistic --mode random --probability 0.50000000000 -j KUBE-SEP-X3P2623AGDH6CDF3
-A KUBE-SVC-NWV5X2332I4OT4T3 -m comment --comment "default/hostnames:" -j KUBE-SEP-57KPRZ3JQVENLNBR

可以看到,这一组规则,实际上是一组随机模式(–mode random)的 iptables 链。

而随机转发的目的地,分别是 KUBE-SEP-WNBA2IHDGP2BOBGZ、KUBE-SEP-X3P2623AGDH6CDF3 和 KUBE-SEP-57KPRZ3JQVENLNBR。

而这三条链指向的最终目的地,其实就是这个 Service 代理的三个 Pod。所以这一组规则,就是 Service 实现负载均衡的位置。

需要注意的是,iptables 规则的匹配是从上到下逐条进行的,所以为了保证上述三条规则每条被选中的概率都相同,我们应该将它们的 probability 字段的值分别设置为 1/3(0.333…)、1/2 和 1。

这么设置的原理很简单:第一条规则被选中的概率就是 1/3;而如果第一条规则没有被选中,那么这时候就只剩下两条规则了,所以第二条规则的 probability 就必须设置为 1/2;类似地,最后一条就必须设置为 1。

通过查看上述三条链的明细,我们就很容易理解 Service 进行转发的具体原理了,如下所示:

-A KUBE-SEP-57KPRZ3JQVENLNBR -s 10.244.3.6/32 -m comment --comment "default/hostnames:" -j MARK --set-xmark 0x00004000/0x00004000
-A KUBE-SEP-57KPRZ3JQVENLNBR -p tcp -m comment --comment "default/hostnames:" -m tcp -j DNAT --to-destination 10.244.3.6:9376

-A KUBE-SEP-WNBA2IHDGP2BOBGZ -s 10.244.1.7/32 -m comment --comment "default/hostnames:" -j MARK --set-xmark 0x00004000/0x00004000
-A KUBE-SEP-WNBA2IHDGP2BOBGZ -p tcp -m comment --comment "default/hostnames:" -m tcp -j DNAT --to-destination 10.244.1.7:9376

-A KUBE-SEP-X3P2623AGDH6CDF3 -s 10.244.2.3/32 -m comment --comment "default/hostnames:" -j MARK --set-xmark 0x00004000/0x00004000
-A KUBE-SEP-X3P2623AGDH6CDF3 -p tcp -m comment --comment "default/hostnames:" -m tcp -j DNAT --to-destination 10.244.2.3:9376

可以看到,这三条链,其实是三条 DNAT 规则。而且在 DNAT 规则之前,iptables 对流入的 IP 包还设置了一个“标志”(–set-xmark)。

DNAT 规则的作用,就是在 PREROUTING 检查点之前,也就是在路由之前,将流入 IP 包的目的地址和端口,改成–to-destination 所指定的新的目的地址和端口。可以看到,这个目的地址和端口,正是被代理 Pod 的 IP 地址和端口。

DNAT规则的作用,就是将流入的IP包的目的地址和端口,改成被代理Pod的IP地址和端口。

这样,访问 Service VIP 的 IP 包经过上述 iptables 处理之后,就已经变成了访问具体某一个后端 Pod 的 IP 包了。

然后,这些 Endpoints 对应的 iptables 规则,正是 kube-proxy 通过监听 Pod 的变化事件,在宿主机上生成并维护的。

3. IPVS 模式

kube-proxy 通过 iptables 处理 Service 的过程,其实需要在宿主机上设置相当多的 iptables 规则。而且,kube-proxy 还需要在控制循环里不断地刷新这些规则来确保它们始终是正确的。

当你的宿主机上有大量 Pod 的时候,成百上千条 iptables 规则不断地被刷新,很明显会影响到整体性能。

所以说,一直以来,基于 iptables 的 Service 实现,都是制约 Kubernetes 项目承载更多量级的 Pod 的主要障碍。

而 IPVS 模式的 Service,就是解决这个问题的一个行之有效的方法。

IPVS 模式的工作原理,其实跟 iptables 模式类似。当我们创建了前面的 Service 之后,kube-proxy 首先会在宿主机上创建一个虚拟网卡(叫作:kube-ipvs0),并为它分配 Service VIP 作为 IP 地址,如下所示:

# ip addr
  ...
  73:kube-ipvs0:<BROADCAST,NOARP>  mtu 1500 qdisc noop state DOWN qlen 1000
  link/ether  1a:ce:f5:5f:c1:4d brd ff:ff:ff:ff:ff:ff
  inet 10.0.1.175/32  scope global kube-ipvs0
  valid_lft forever  preferred_lft forever

而接下来,kube-proxy 就会通过 Linux 的 IPVS 模块,为这个 IP 地址设置三个 IPVS 虚拟主机,并设置这三个虚拟主机之间使用轮询模式 (rr) 来作为负载均衡策略。我们可以通过 ipvsadm 查看到这个设置,如下所示:

# ipvsadm -ln
 IP Virtual Server version 1.2.1 (size=4096)
  Prot LocalAddress:Port Scheduler Flags
    ->  RemoteAddress:Port           Forward  Weight ActiveConn InActConn     
  TCP  10.102.128.4:80 rr
    ->  10.244.3.6:9376    Masq    1       0          0         
    ->  10.244.1.7:9376    Masq    1       0          0
    ->  10.244.2.3:9376    Masq    1       0          0

可以看到,这三个 IPVS 虚拟主机的 IP 地址和端口,对应的正是三个被代理的 Pod。

这时候,任何发往 10.102.128.4:80 的请求,就都会被 IPVS 模块转发到某一个后端 Pod 上了。

而相比于 iptables,IPVS 在内核中的实现其实也是基于 Netfilter 的 NAT 模式,所以在转发这一层上,理论上 IPVS 并没有显著的性能提升。但是,IPVS 并不需要在宿主机上为每个 Pod 设置 iptables 规则,而是把对这些“规则”的处理放到了内核态,从而极大地降低了维护这些规则的代价。

不过需要注意的是,IPVS 模块只负责上述的负载均衡和代理功能。而一个完整的 Service 流程正常工作所需要的包过滤、SNAT 等操作,还是要靠 iptables 来实现。

4. DNS

在 Kubernetes 中,Service 和 Pod 都会被分配对应的 DNS A 记录(从域名解析 IP 的记录),由 kube-dns 模块负责。

对于 ClusterIP 模式的 Service 来说(比如我们上面的例子),它的 A 记录的格式是:<serviceName>.<namespace>.svc.cluster.local。当你访问这条 A 记录的时候,它解析到的就是该 Service 的 VIP 地址。

而对于指定了 clusterIP=None 的 Headless Service 来说,它的 A 记录的格式也是:<podName>.<serviceName>.<namesapce>.svc.cluster.local。但是,当你访问这条 A 记录的时候,它返回的是所有被代理的 Pod 的 IP 地址的集合。

当然,如果你的客户端没办法解析这个集合的话,它可能会只会拿到第一个 Pod 的 IP 地址。

此外,对于 ClusterIP 模式的 Service 来说,它代理的 Pod 被自动分配的 A 记录的格式是:podIp.myNameSpace.pod.cluster.local。这条记录指向 Pod 的 IP 地址。

而对 Headless Service 来说,它代理的 Pod 被自动分配的 A 记录的格式是:myPodName.myServiceName.myNameSpace.svc.cluster.local。这条记录也指向 Pod 的 IP 地址。

5. 小结

所谓 Service,其实就是 Kubernetes 为 Pod 分配的、固定的、基于 iptables(或者 IPVS)的访问入口。而这些访问入口代理的 Pod 信息,则来自于 Etcd,由 kube-proxy 通过控制循环来维护。

Service 原理:

  • 1)首先给 Service 分配一个VIP,然后增加 iptables 规则将访问该 IP 的请求转发到后续的 iptables 链。
    • KUBE-SERVICES 或者 KUBE-NODEPORTS 规则对应的 Service 的入口链,这个规则应该与 VIP 和 Service 端口一一对应;
  • 2)iptables 链实际是一个集合,包含了各个 Pod 的IP(这些称为 Service 的 Endpoints),使用 Round Robin 方式的负载均衡。
    • KUBE-SEP-(hash) 规则对应的 DNAT 链,这些规则应该与 Endpoints 一一对应;
    • KUBE-SVC-(hash) 规则对应的负载均衡链,这些规则的数目应该与 Endpoints 数目一致;
  • 3)然后,这些 Endpoints 对应的 iptables 规则,正是 kube-proxy 通过监听 Pod 的变化事件,在宿主机上生成并维护的。

上述模式需要维护大量 iptables,在大量Pod的情况下,性能不佳,于是出现了 IPVS 模式。以创建虚拟网卡,并分配虚拟IP的形式,直接使用Linux 的 IPVS 模块,由于将转发逻辑放到了 Linux 内核中执行,性能上有所提升。

DNS:

在 Kubernetes 中,Service 和 Pod 都会被分配对应的 DNS A 记录(从域名解析 IP 的记录)。

  • ClusterIP:<serviceName>.<namespace>.svc.cluster.local
  • Headless Service:<podName>.<serviceName>.<namesapce>.svc.cluster.local

如果你对云原生技术充满好奇,想要深入了解更多相关的文章和资讯,欢迎关注微信公众号。

扫描下方二维码或搜索公众号【探索云原生】即可订阅


6. 参考

https://kubernetes.io/docs/concepts/services-networking/service/

https://draveness.me/kubernetes-service/

深入剖析Kubernetes

【云原生 • Kubernetes】认识 k8s、k8s 集群、核心原理介绍 Kubernetes(k8s)是Google开源的容器集群管理系统(谷歌内部:Borg)。在Docker技术的基础上,为容器化的应用提供部署运行、资源调度、服务发现和动态伸缩等一系列完整功能,提高了大规模容器集群管理的便捷性。 阅读详情

相关推荐

StarWind V2V Converter v9 虚拟磁盘转换工具使用教程 (转)

StarWind V2V Converter v9.0.1.268 是一款免费的虚拟磁盘转换工具,支持不同管理程序间的虚拟机镜像格式转换,包括VMDK、VHD/VHDX、IMG和QCOW2等格式。该工具具有窗口修复模式、零拷贝转换和管理程序切换等特色功能,能够轻松实现物理机到虚拟机的转换,并兼容主流管理程序如Hyper-V、ESXi等。使用教程详细介绍了从本地文件选择到格式转换的完整操作流程,转换过程简单高效且不影响原虚拟磁盘数据。

hsh的专栏 1484

Kubernetes系列05:深入掌握Service

Service是kubernetes最核心的概念,通过创建Service,可以为一组具有相同功能的容器应用提供一个统一的入口地址,并且将请求进行负载分发到后端的各个容器应用上。 本节对Service的使用进行说明,包括Service的负载均衡、外网访问、DNS服务的搭建、Ingress7层路由机制等 1.Service定义详解 yaml格式的Service定义文件的完整内容: apiV

TURING.DT 1万+

K8S核心原理

k8s核心原理

失眠忍者 2182

TCN(Temporal Convolutional Networks)时序卷积网络详解及代码

TCN(Temporal Convolutional Networks)时序卷积网络详解及代码

zhulewen的博客 7885

ZYNQ平台AXI DMA传输避坑指南:如何快速定位‘errors:200‘等中断故障

本文详细解析了ZYNQ平台AXI DMA传输中常见的'errors:200'等中断故障,提供了从寄存器解析到压力测试的完整解决方案。通过深入分析XILINX_DMA中断机制、错误分类及五步排查法,帮助开发者快速定位并解决DMA传输问题,提升系统稳定性与性能。

weixin_29159613的博客 441

kubernetes(Jenkins、kubernetes核心、K8s实战-KubeSphere、)

手动部署# 1:表示stdout标准输出 2:表示stderr标准错误 &:等效于标准输出# 2>&1,意思是错误输出等同于标准输出。把标准输出和错误输出全部导入日志xxx.log里。创建没有任务的容器 不停止docker run -d --name 容器名称 -p 端口号:端口号 镜像名称 sleep infinityDevOps:Development和Operations的组合词,它是一种重视软件开发人员(Dev)和IT运维技术人员(Ops)之间沟通合作的文化、运动或惯例。

小丁的博客 2479

【AI智能体】Coze 数据库从使用到实战操作详解

Coze 数据库使用到实战详解

congge 5917

【云原生 | 从零开始学Kubernetes】十七、Kubernetes核心技术Service

随机轮询响应比。

欢迎关注,一起进步! 2774

华为OD机试真题新系统-空间占用计算(Py/Java/C/C++/Js/Go)

华为OD机试新系统机试真题 【空间占用计算】,提供C语言、Java、C++、Python、Go、JavaScript源码实现,并提供完整思路讲解,以及在线OJ模拟做题。华为OD机试真题【空间占用计算】。

qq_45776114的博客 3452

【教程4>第1章>第8节】ILA在线调试工具与MATLAB联合应用

Vivado的ILA(Integrated Logic Analyzer)核是一种可定制的集成逻辑分析仪内核,专门用于监控设计的内部信号。ILA内核包含了现代逻辑分析仪的许多高级功能,例如布尔触发方程和边沿转换触发等。此外,由于ILA内核与被监控的设计保持同步,因此应用于设计的所有设计时钟约束也会应用于ILA内核内部的组件。ILA核的主要应用是在硬件设计和验证阶段进行调试。通过监控关键信号,设计师可以了解硬件的实际行为,从而找出并修复设计中的错误。ILA核还可以用于分析设计的性能。

FPGA/MATLAB学习教程/源码/项目合作开发 801

Kubernetes快速实战与核心原理剖析(1)

Controller 负责监控和调整在 Worker Node 上部署的服务的状态,比如用户要求 A 服务部署 2 个副本,那么当其中一个服务挂了的时候,Controller 会马 上调整,让 Scheduler 再选择一个 Worker Node 重新部署服务。Kubelet 是 Master Node 安插在 Worker Node 上的“眼线”,它会定期向 Master Node 汇报自己 Node 上运行的服务的状态,并接受来自 Master Node 的指示采取调整措施。

Suunhp_N的博客 1982

小工匠聊架构-分布式场景下的并发幂等性常见的解决方案

Pre 我们来回顾下单体时代 单体时代,应用部署在一台主机上,可以使用JVM级别的锁来控制并发请求 。 随着应用规模的不断扩大,集群化或者微服务化的分布式部署越来越普及,每个应用都是一个单独的JVM应用,所以单体时代的这种处理方式已经无法满足当前架构下的业务需求了。 JVM级别的锁已经无法满足跨进程之间访问控制了,进而演化出来了分布式锁。 分布式锁 能否解决幂等性问题? 分布式锁解决什么问题? 简言之: 解决跨进程间无法共享本地资源的问题 ,解决的是分布式场景下并发访问的问题。 为什么需要确保并发.

小工匠 2万+

K8S架构原理【详解】

对K8S简单的理解提示:以下是本篇文章正文内容,下面案例可供参考Kubernetes 是一个可移植、可扩展的、开源的容器管理平台,简称 Kubernetes。什么是可移植?可移植:在 kubernetes 中部署的应用都是基于镜像的,镜像是可移植的,可以被多个环境使用,可以从一个环境迁移到另一个环境。什么是可扩展?可扩展:安装 Kubernetes的节点可以根据业务规模动态扩缩容、Kubernetes中的 pod 应用也可以实现自动扩缩容。

qq_46021810的博客 3769

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

Kubernetes(K8s)的Service解析

Kubernetes(简称K8s)中的Service是一种核心资源对象,它为一组提供相同功能的Pod提供了稳定、统一的网络入口点,并负责服务发现、负载均衡以及网络路由。

专注于数据库技术分享,包含但不限于Oracle,MySQL,PostgreSQL,ElasticSearch及国产数据库等 1136

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

什么是Kubernetes?K8s基础与工作原理

Kubernetes,通常简称为K8s,是一个用于自动化部署、扩展和管理容器化应用程序的开源容器编排平台。它由 Google 于 2014 年开源,后来交由 CNCF(Cloud Native Computing Foundation)管理。Kubernetes 的名字来自希腊语,意思是“舵手”或“飞行员”,表明它的作用是为容器化应用提供控制与调度。

java开发 2670

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

一文读懂 Kubernetes(K8s):从核心概念到组件交互

摘要: Kubernetes(K8s)是云原生时代的容器编排标准,通过主从架构实现自动化运维、跨环境一致性和资源高效利用。核心组件包括Master节点(kube-apiserver、etcd等)负责决策,Worker节点(kubelet、kube-proxy等)负责执行,配合附加组件(如CoreDNS)增强功能。用户通过定义Pod、Service等资源对象描述需求,K8s基于“声明式API”自动调整状态。典型部署流程涵盖请求提交、调度、容器创建等环节,最终实现基础设施的代码化管理。理解K8s的核心在于掌握其

weixin_62782025的博客 5216

【K8S】Kubernetes架构与原理详解

我们学习了 Docker,知道了如何将应用打包成容器。但当容器数量变多、服务器变多时,手动管理就变得不现实了。这时候就需要一个"容器管家"来帮我们自动化管理,它就是 Kubernetes(简称 K8s)。本文将带你深入理解 K8s 的架构和工作原理。

weixin_63434398的博客 2143

【云原生 | 从零开始学Kubernetes】十八、Kubernetes核心技术Service实战

通过实例介绍了service的类型以及创建

欢迎关注,一起进步! 5700

Kubernetes(K8s)详解

Kubernetes(K8S)是一个开源的容器编排引擎,用于自动化部署、扩缩和管理容器化应用。其核心架构包括Master Node(含API Server、Scheduler、Controller Manager等组件)和Worker Node(含Kubelet、Kube-Proxy等)。K8S提供核心特性如服务发现、存储编排、自我修复等,支持通过kubectl命令行工具进行资源管理。Namespace用于隔离资源,Pod是最小部署单元,而Deployment则管理Pod的多副本和自愈能力。通过YAML文件

Java资料站 2013

Kubernetes k8s理论篇

目录 一、k8s概述 1.1 什么是k8s? 1.1.1 作用 1.1.2 由来 1.1.3 含义 1.2 为什么需要K8S K8S的目标是让部署容器化应用简单高效。 1.3 k8s的特性 二、Kubernetes集群架构与组件 2.1Master组件 2.1.1Kube-apiserver 2.1.2 Kube-controller-manager 2.1.3 Kube-scheduler 2.1.4 配置存储中心 — etcd 2.2 Node组件 2.2.1 Kub..

weixin_48872590的博客 5万+

Kubernetes学习之K8S组件运行原理详解总结

目录 一、看图说K8S 二、K8S的概念和术语 三、K8S集群组件 1、Master组件 2、Node组件 3、核心附件 四、K8S的网络模型 五、Kubernetes的核心对象详解 1、Pod资源对象 2、Controller 3、Service 一、看图说K8S 先从一张大图来观看一下K8S是如何运作的,再具体去细化K8S的概念、组件以及网络模型。 从上图,我们可以看到K8S组件和逻辑及其复杂,但是这并不可怕,我们从宏观上先了解K8S是怎么用的,.

Jian Sun_的博客 1686

K8S Service

Kubernetes(通常简写为K8s)中的Service是一种核心资源对象,它用于将一组Pod(容器组)抽象为一个单一的服务,使得这些Pod能够对外提供稳定的服务入口。

王小工小工历程 2159

【K8S】Kubernetes初探

K8S是什么? K8S是Kubernetes的缩写(首字母K+中间8个字母+末尾字母S),是一个高度自动化的资源控制系统,它通过跟踪配置库里保存的“资源期望状态”与当前环境的“实际资源状态”之间的差异来实现自动控制。例如在某节点宕机时,自动迁移服务单元到新的节点上。 核心词汇解释 (1)镜像 此处的镜像和容器都是docker中的概念,不过这里的镜像与我们常用...

阳阳的博客 3770

K8s设计架构与核心原理详解

Kubernetes设计架构与核心原理详解

qq_49096347的博客 1645

零基础学kubernetes(k8s)必看教程,带你10分钟快速实战入门k8s

零基础学kubernetes(k8s)必看教程,带你10分钟快速实战入门k8s

weixin_53096649的博客 3737
上一篇: Kubernetes教程(三)---纯三层网络方案
下一篇: Kubernetes教程(五)---Service 的几种访问方式
探索云原生
博客等级 码龄9年 730粉丝 131原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值