<!--{subtemplate common/header_common}-->	<!--{if $_GET['mod'] == 'viewthread' && !empty($_G['tid'])}-->
	<link rel="canonical" href="https://www.qidao123.com/bbs/thread-{$_G['tid']}-1-1.html" />
	<!--{elseif $_GET['mod'] == 'forumdisplay' && !empty($_G['fid'])}-->
	<link rel="canonical" href="https://www.qidao123.com/bbs/forum-{$_G['fid']}-1.html" />
	<!--{elseif $_GET['mod'] == 'guide'}-->
	<link rel="canonical" href="https://www.qidao123.com/bbs/guide/" />
	<!--{elseif $_G['basescript'] == 'forum' && (empty($_GET['mod']) || $_GET['mod'] == 'index')}-->
	<link rel="canonical" href="https://www.qidao123.com/bbs/" />
	<!--{/if}-->
	r`n`t<meta name="application-name" content="$_G['setting']['bbname']" />
	<meta name="msapplication-tooltip" content="$_G['setting']['bbname']" />
	<!--{if $_G['setting']['portalstatus']}--><meta name="msapplication-task" content="name=$_G['setting']['navs'][1]['navname'];action-uri={echo !empty($_G['setting']['domain']['app']['portal']) ? $_G['scheme'].'://'.$_G['setting']['domain']['app']['portal'] : $_G[siteurl].'portal.php'};icon-uri={$_G[siteurl]}{IMGDIR}/portal.ico" /><!--{/if}-->
	<meta name="msapplication-task" content="name=$_G['setting']['navs'][2]['navname'];action-uri={echo !empty($_G['setting']['domain']['app']['forum']) ? $_G['scheme'].'://'.$_G['setting']['domain']['app']['forum'] : $_G[siteurl].'forum.php'};icon-uri={$_G[siteurl]}{IMGDIR}/bbs.ico" />
	<!--{if $_G['setting']['groupstatus']}--><meta name="msapplication-task" content="name=$_G['setting']['navs'][3]['navname'];action-uri={echo !empty($_G['setting']['domain']['app']['group']) ? $_G['scheme'].'://'.$_G['setting']['domain']['app']['group'] : $_G[siteurl].'group.php'};icon-uri={$_G[siteurl]}{IMGDIR}/group.ico" /><!--{/if}-->
	<!--{if helper_access::check_module('feed')}--><meta name="msapplication-task" content="name=$_G['setting']['navs'][4]['navname'];action-uri={echo !empty($_G['setting']['domain']['app']['home']) ? $_G['scheme'].'://'.$_G['setting']['domain']['app']['home'] : $_G[siteurl].'home.php'};icon-uri={$_G[siteurl]}{IMGDIR}/home.ico" /><!--{/if}-->
	<!--{if $_G['basescript'] == 'forum' && $_G['setting']['archiver']}-->
		<link rel="archives" title="$_G['setting']['bbname']" href="{$_G[siteurl]}archiver/" />
	<!--{/if}-->
	<!--{if !empty($rsshead)}-->$rsshead<!--{/if}-->
	<!--{if widthauto()}-->
		<link rel="stylesheet" id="css_widthauto" type="text/css" href='{$_G['setting']['csspath']}{STYLEID}_widthauto.css?{VERHASH}' />
		<script type="text/javascript">HTMLNODE.className += ' widthauto'</script>
	<!--{/if}-->
	<!--{if $_G['basescript'] == 'forum' || $_G['basescript'] == 'group'}-->
		<script type="text/javascript" src="{$_G[setting][jspath]}forum.js?{VERHASH}"></script>
	<!--{elseif $_G['basescript'] == 'home'}-->
		<script type="text/javascript" src="{$_G[setting][jspath]}home.js?{VERHASH}"></script>
	<!--{elseif $_G['basescript'] == 'portal'}-->
		<script type="text/javascript" src="{$_G[setting][jspath]}portal.js?{VERHASH}"></script>
	<!--{/if}-->
	<!--{if $_G['basescript'] != 'portal' && $_GET['diy'] == 'yes' && check_diy_perm($topic)}-->
		<script type="text/javascript" src="{$_G[setting][jspath]}portal.js?{VERHASH}"></script>
	<!--{/if}-->
	<!--{if $_GET['diy'] == 'yes' && check_diy_perm($topic)}-->
		<link rel="stylesheet" type="text/css" id="diy_common" href="{$_G['setting']['csspath']}{STYLEID}_css_diy.css?{VERHASH}" />
	<!--{/if}-->
</head>

<body id="nv_{$_G[basescript]}" class="pg_{CURMODULE}{if $_G['basescript'] === 'portal' && CURMODULE === 'list' && !empty($cat)} {$cat['bodycss']}{/if}" onkeydown="if(event.keyCode==27) return false;">
	<div id="append_parent"></div><div id="ajaxwaitid"></div>
	<!--{if $_GET['diy'] == 'yes' && check_diy_perm($topic)}-->
		<!--{template common/header_diy}-->
	<!--{/if}-->
	<!--{if check_diy_perm($topic)}-->
		<!--{template common/header_diynav}-->
	<!--{/if}-->
	<!--{if CURMODULE == 'topic' && $topic && empty($topic['useheader']) && check_diy_perm($topic)}-->
		$diynav
	<!--{/if}-->
	<!--{if empty($topic) || $topic['useheader']}-->
		<!--{if $_G['setting']['mobile']['allowmobile'] && (!$_G['setting']['cacheindexlife'] && !$_G['setting']['cachethreadon'] || $_G['uid']) && ($_GET['diy'] != 'yes' || !$_GET['inajax']) && ($_G['mobile'] != '' && $_G['cookie']['mobile'] == '' && $_GET['mobile'] != 'no')}-->
			<div class="xi1 bm bm_c">
			    {lang your_mobile_browser}<a href="{$_G['siteurl']}forum.php?mobile=yes">{lang go_to_mobile}</a> <span class="xg1">|</span> <a href="$_G['setting']['mobile']['nomobileurl']">{lang to_be_continue}</a>
			</div>
		<!--{/if}-->
		<!--{if !empty($_G['setting']['shortcut']) && $_G['member'][credits] >= $_G['setting']['shortcut']}-->
			<div id="shortcut">
				<span><a href="javascript:;" id="shortcutcloseid" title="{lang close}">{lang close}</a></span>
				{lang shortcut_notice}
				<a href="javascript:;" id="shortcuttip">{lang shortcut_add}</a>

			</div>
			<script type="text/javascript">setTimeout(setShortcut, 2000);</script>
		<!--{/if}-->
		<div id="toptb" class="cl">
			<!--{hook/global_cpnav_top}-->
			<div class="wp">
				<div class="z">
					<!--{loop $_G['setting']['topnavs'][0] $nav}-->
						<!--{if is_array($nav) && $nav['available'] && (!$nav['level'] || ($nav['level'] == 1 && $_G['uid']) || ($nav['level'] == 2 && $_G['adminid'] > 0) || ($nav['level'] == 3 && $_G['adminid'] == 1))}-->$nav[code]<!--{/if}-->
					<!--{/loop}-->
					<!--{hook/global_cpnav_extra1}-->
				</div>
				<div class="y">
					<a id="switchblind" href="javascript:;" onclick="toggleBlind(this)" title="{lang switch_blind}" class="switchblind"></a>
					<!--{hook/global_cpnav_extra2}-->
					<!--{loop $_G['setting']['topnavs'][1] $nav}-->
						<!--{if is_array($nav) && $nav['available'] && (!$nav['level'] || ($nav['level'] == 1 && $_G['uid']) || ($nav['level'] == 2 && $_G['adminid'] > 0) || ($nav['level'] == 3 && $_G['adminid'] == 1))}-->$nav[code]<!--{/if}-->
					<!--{/loop}-->
					<!--{if empty($_G['disabledwidthauto']) && $_G['setting']['switchwidthauto']}-->
						<a href="javascript:;" id="switchwidth" onclick="widthauto(this)" title="{if widthauto()}{lang switch_narrow}{else}{lang switch_wide}{/if}" class="switchwidth"><!--{if widthauto()}-->{lang switch_narrow}<!--{else}-->{lang switch_wide}<!--{/if}--></a>
					<!--{/if}-->
					<!--{if $_G['uid'] && !empty($_G['style']['extstyle'])}--><a id="sslct" href="javascript:;" onmouseover="delayShow(this, function() {showMenu({'ctrlid':'sslct','pos':'34!'})});">{lang changestyle}</a><!--{/if}-->
					<!--{if check_diy_perm($topic)}-->
						$diynav
					<!--{/if}-->
				</div>
			</div>
		</div>

		<!--{if !IS_ROBOT}-->
			<!--{if $_G['uid'] && !$_G['setting']['bbclosed'] && empty($_G['member']['freeze']) && $_G['member']['groupid'] != 5}-->
			<ul id="myprompt_menu" class="p_pop" style="display: none;">
				<li><a href="home.php?mod=space&do=pm" id="pm_ntc" style="background-repeat: no-repeat; background-position: 0 50%;"><em class="prompt_news{if empty($_G[member][newpm])}_0{/if}"></em>{lang pm_center}</a></li>
				<!--{if $_G['setting']['followstatus']}-->
					<li><a href="home.php?mod=follow&do=follower"><em class="prompt_follower{if empty($_G[member][newprompt_num][follower])}_0{/if}"></em><!--{lang notice_interactive_follower}-->{if $_G[member][newprompt_num][follower]}($_G[member][newprompt_num][follower]){/if}</a></li>
					<!--{if $_G[member][newprompt] && $_G[member][newprompt_num][follow]}-->
						<li><a href="home.php?mod=follow"><em class="prompt_concern"></em><!--{lang notice_interactive_follow}-->($_G[member][newprompt_num][follow])</a></li>
					<!--{/if}-->
				<!--{/if}-->
				<!--{if $_G[member][newprompt]}-->
					<!--{loop $_G['member']['category_num'] $key $val}-->
						<li><a href="home.php?mod=space&do=notice&view=$key"><em class="notice_$key"></em><!--{echo lang('template', 'notice_'.$key)}-->(<span class="rq">$val</span>)</a></li>
					<!--{/loop}-->
				<!--{/if}-->
				<!--{if empty($_G['cookie']['ignore_notice'])}-->
					<li class="ignore_noticeli"><a href="javascript:;" onclick="setcookie('ignore_notice', 1);hideMenu('myprompt_menu')" title="{lang temporarily_to_remind}"><em class="ignore_notice"></em></a></li>
				<!--{/if}-->
			</ul>
			<!--{/if}-->
			<!--{if $_G['uid'] && !empty($_G['style']['extstyle'])}-->
				<div id="sslct_menu" class="cl p_pop" style="display: none;">
					<!--{if !$_G[style][defaultextstyle]}--><span class="sslct_btn" onclick="extstyle('')" title="{lang default}"><i></i></span><!--{/if}-->
					<!--{loop $_G['style']['extstyle'] $extstyle}-->
						<span class="sslct_btn" onclick="extstyle('$extstyle[0]')" title="$extstyle[1]"><i style='background:$extstyle[2]'></i></span>
					<!--{/loop}-->
				</div>
			<!--{/if}-->
			<!--{if $_G['uid']}-->
				<ul id="myitem_menu" class="p_pop" style="display: none;">
					<!--{if $_G['setting']['forumstatus']}--><li><a href="home.php?mod=space&do=thread&view=me">{lang mypost}</a></li><!--{/if}-->
					<!--{if $_G['setting']['favoritestatus']}--><li><a href="home.php?mod=space&do=favorite&view=me">{lang favorite}</a></li><!--{/if}-->
					<!--{if $_G['setting']['friendstatus']}--><li><a href="home.php?mod=space&do=friend">{lang friends}</a></li><!--{/if}-->
					<!--{hook/global_myitem_extra}-->
				</ul>
			<!--{/if}-->
			<!--{subtemplate common/header_qmenu}-->
		<!--{/if}-->

		<!--{ad/headerbanner/wp a_h}-->
		<div id="hd">
			<div class="wp">
				<div class="hdc cl">
					<!--{eval $mnid = getcurrentnav();}-->
					<h2><!--{if !isset($_G['setting']['navlogos'][$mnid])}--><a href="{if $_G['setting']['domain']['app']['default']}{$_G['scheme']}://{$_G['setting']['domain']['app']['default']}/{else}./{/if}" title="$_G['setting']['bbname']">{$_G['style']['boardlogo']}</a><!--{else}-->$_G['setting']['navlogos'][$mnid]<!--{/if}--></h2>
					<!--{template common/header_userstatus}-->
				</div>

				<div id="nv">
					<a href="javascript:;" id="qmenu" onmouseover="delayShow(this, function () {showMenu({'ctrlid':'qmenu','pos':'34!','ctrlclass':'a','duration':2});showForummenu($_G[fid]);})">{lang my_nav}</a>
					<ul>
						<!--{loop $_G['setting']['navs'] $nav}-->
							<!--{if is_array($nav) && $nav['available'] && (!$nav['level'] || ($nav['level'] == 1 && $_G['uid']) || ($nav['level'] == 2 && $_G['adminid'] > 0) || ($nav['level'] == 3 && $_G['adminid'] == 1))}--><li {if $mnid == $nav[navid] || substr($_SERVER['REQUEST_URI'], 1) == str_replace('./', '', $nav[filename])}class="a" {/if}$nav[nav]></li><!--{/if}-->
						<!--{/loop}-->
					</ul>
					<!--{hook/global_nav_extra}-->
				</div>
				<!--{if !empty($_G['setting']['plugins']['jsmenu'])}-->
					<ul class="p_pop h_pop" id="plugin_menu" style="display: none">
					<!--{loop $_G['setting']['plugins']['jsmenu'] $module}-->
						 <!--{if in_array($module['adminid'], array(0, -1)) || ($module['adminid'] && $_G['adminid'] > 0 && $module['adminid'] >= $_G['adminid'])}-->
						 <li>$module[url]</li>
						 <!--{/if}-->
					<!--{/loop}-->
					</ul>
				<!--{/if}-->
				$_G[setting][menunavs]
				<div id="mu" class="cl">
				<!--{if $_G['setting']['subnavs']}-->
					<!--{loop $_G[setting][subnavs] $navid $subnav}-->
						<!--{if $_G['setting']['navsubhover'] || $mnid == $navid}-->
						<ul class="cl {if $mnid == $navid}current{/if}" id="snav_$navid"{if $mnid != $navid} style="display:none"{/if}>
						$subnav
						</ul>
						<!--{/if}-->
					<!--{/loop}-->
				<!--{/if}-->
				</div>
				<!--{ad/subnavbanner/a_mu}-->
				<!--{subtemplate common/pubsearchform}-->
			</div>
		</div>

		<!--{hook/global_header}-->
	<!--{/if}-->

	<div id="wp" class="wp">

qidao123.com ToB IT社区-企服评测·应用市场»论坛 › 容器及微服务 › 容器及微服务 › k8s svc详解
返回列表 发新帖

k8s svc详解

[复制链接]
发表于 2026-5-17 15:38:08 | 显示全部楼层 |阅读模式
一、k8s svc详解


  • 先容了pod之间怎么通讯的，可以通过ClusterIP,dns,pod ip直接通讯
  • dns比力风趣 web-svc.default.svc.cluster.local
  • pod对外提供服务就必要NodePort,LoadBalance
  • 如果还对七层有要求的话，就必要ingress
1、为什么必要这个svc呢？


  • 核心缘故起因

    • pod的ip不固定，pod重启，重新调理后ip会厘革
    • 如果没有svc，就必要直接访问pod的ip，但是pod的ip一但厘革的，全部依赖这个设置的都必要重新设置，在生产情况中是不可继续的

  • 办理了核心的题目

    • 稳固的网络入口，提供了一个假造的ip(clusterip)和dns名称，就是不必要管后端pod的厘革了
    • 实现了负载均衡，svc主动的将流量转发到后端的pod,无需设置额外的负载均衡器
    • 服务发现，集群内的其他组件可以通过dns直接访问

1、svc的设置



  • 也是通过标签关联一组pod
创建一个nginx，svc
  1. [root@master01 svc]# kubectl create deployment web1 --image=nginx --dry-run=client -o yaml > web1.yml
  3. # 查看pod的ip地址
  4. [root@master01 svc]# kubectl get pod -o wide
  5. NAME                  READY   STATUS    RESTARTS   AGE     IP              NODE       NOMINATED NODE   READINESS GATES
  6. web1-8fd498dd-klfrx   1/1     Running   0          6m17s   10.246.73.146   node       <none>           <none>
  7. web1-8fd498dd-nch98   1/1     Running   0          6m17s   10.244.59.197   master02   <none>           <none>
  9. [root@master01 svc]# kubectl expose deployment web1 --port=80 --target-port=80 --type=ClusterIP
  10. service/web1 exposed
  11. [root@master01 svc]# kubectl describe svc web1
  12. Name:              web1
  13. Namespace:         default
  14. Labels:            app=web1  # 选择的标签
  15. Annotations:       <none>
  16. Selector:          app=web1
  17. Type:              ClusterIP
  18. IP Family Policy:  SingleStack
  19. IP Families:       IPv4
  20. IP:                10.110.146.0
  21. IPs:               10.110.146.0
  22. Port:              <unset>  80/TCP
  23. TargetPort:        80/TCP
  24. Endpoints:         10.244.59.197:80,10.246.73.146:80  # 关联上带app=web1的pod了
  25. Session Affinity:  None
  26. Events:            <none>
  28. # svc下面还有一个endpoints关联pod
  29. [root@master01 svc]# kubectl get endpoints
  30. NAME         ENDPOINTS                               AGE
  31. kubernetes   192.168.50.20:6443,192.168.50.21:6443   7d5h
  32. web1         10.244.59.197:80,10.246.73.146:80       2m4s
  34. # pod被删除了，这个ip也会变化，也会被endpoints重新记录新的pod的ip
  35. [root@master01 svc]# kubectl delete pod web1-8fd498dd-klfrx
  36. pod "web1-8fd498dd-klfrx" deleted
  38. [root@master01 svc]# kubectl get endpoints
  39. NAME         ENDPOINTS                               AGE
  40. kubernetes   192.168.50.20:6443,192.168.50.21:6443   7d5h
  41. web1         10.244.59.197:80,10.246.73.145:80       3m28s
复制代码
访问
  1. # 集群内部访问clusterip 就能访问到pod提供的业务了，发现是轮询的，实现了负载均衡的效果
  3. [root@master01 svc]# curl 10.110.146.0
  4. 456
  5. [root@master01 svc]# curl 10.110.146.0
  6. 123
复制代码

  • 集群外貌是不能通过clusterip访问的，必要借助其他的nodeport等等
2、kube-proxy详解

1、kube-proxy是什么


  • 在每一个节点上必须跑的一个署理步调，专门负责实现svc的网络转发本领(集群内部的调理员+规则设置员)
svc是一个设置，不会自己转发流量,kube-proxy才是干活的人


  • 监听svc和endpoint的厘革，知道哪些svc对应哪些pod的ip
  • 在节点上设置网络规则，ipvs和iptables规则
  • 实现服务访问和负载均衡的，当访问svc ip时，将流量转发到后端的pod上


  • 修改kube-proxy的模式为iptables
有一个存储kube-proxy的设置文件为configmap,修改后，删除全部pod,设置就会更新过来
  1. [root@master01 ~]# kubectl edit cm -n kube-system kube-proxy
  3.     mode: iptables
  5. # 删除kube-proxy关联的pod
  6. [root@master01 ~]# kubectl delete pods -n kube-system -l k8s-app=kube-proxy
  7. pod "kube-proxy-95mlq" deleted
  8. pod "kube-proxy-svx52" deleted
  9. pod "kube-proxy-tzts4" deleted
  11. # 会重新创建出来,配置也被更新了
  12. [root@master01 ~]# kubectl get pod -n kube-system -l k8s-app=kube-proxy
  13. NAME               READY   STATUS    RESTARTS   AGE
  14. kube-proxy-bs4rg   1/1     Running   0          5s
  15. kube-proxy-kzknc   1/1     Running   0          4s
  16. kube-proxy-zq975   1/1     Running   0          4s
  18. # 查看日志日志，发现使用了iptables规则
  19. [root@master01 ~]# kubectl logs -n kube-system kube-proxy-bs4rg
  20. I0401 07:39:33.514227       1 node.go:163] Successfully retrieved node IP: 192.168.50.22
  21. I0401 07:39:33.514303       1 server_others.go:138] "Detected node IP" address="192.168.50.22"
  22. I0401 07:39:33.532944       1 server_others.go:206] "Using iptables Proxier"
  24. # 查看iptables规则
  25. [root@master01 ~]# iptables -t nat -L -n | grep 10.110.237.145
  26. KUBE-SVC-CWMY3MEVXVILAFTH  tcp  --  0.0.0.0/0            10.110.237.145       /* default/v1 cluster IP */ tcp dpt:80
  27. KUBE-MARK-MASQ  tcp  -- !10.240.0.0/12        10.110.237.145       /* default/v1 cluster IP */ tcp dpt:80
复制代码
2、kube-proxy和svc的区别


  • 关系是，svc是访问的入口，kube-proxy是实现这个入口转发本领的节点署理进程
  • svc是提供稳固的假造ip,端口和负载均衡入口，通过标签选择一组pod,自己是不处置惩罚流量的
  • kube-proxy每个节点上运行的进程，监听svc和endpoints厘革，在节点上设置ipvs/iptables规则，实现流量转发和负载均衡，是svc的实验者
  • svc和kube-proxy共同利用

    • svc界说访问的计谋，端口，稳固的入口
    • kube-proxy,实现这些svc界说的计谋，实现流量转发的本领
    • 没有svc，不知道怎么访问
    • 没有kube-proxy，有svc，但是没有现实的流量转发本领，也访问不到

3、服务发现


  • 就是pod之间通过这些来举行通讯
  • 服务发现流程，就是pod访问别的一个pod的场景

    • 容器内部举行dns剖析，指向了core-dns
    • core-dns查询当地的缓存，找到对应的svc
    • 得到应用的ip
    • 发送哀求到该ip
    • kube-proxy的iptables/ipvs规则
    • 转发到后端的pod

1、clusterip


  • 是svc的默认范例，为svc分配一个集群内部专用的假造ip,只能在集群内部举行访问
  • 这个ip网段，在创建k8s集群的时间，可以指定的，差别的网段，底层是买通的
  • 是一个假造网卡，没有实体的网卡绑定
  • 仅存在iptables/ipvs规则中，通过kube-proxy实现流量的转发
  • 等完成后，将kube-proxy模式改为iptables，就能看到iptables规则了
继续看我们上面完成的实验
  1. # type的类型是clusterip
  2. # 虚拟ip为10.110.146.0
  3. # 监听的端口是80的   这个ip和端口都是虚拟出来的
  4. [root@master01 svc]# kubectl get svc web1
  5. NAME   TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)   AGE
  6. web1   ClusterIP   10.110.146.0   <none>        80/TCP    17m
  8. # 访问这个虚拟ip就能访问pod了
  10. # 查看ipvs规则
  11. # ipvsadm -ln
  12. # 关联的pod的ip
  13. TCP  10.110.146.0:80 rr
  14.   -> 10.244.59.197:80             Masq    1      0          0         
  15.   -> 10.246.73.145:80             Masq    1      0          0
复制代码
2、dns方式


  • 集群内里有core-dns这个pod，这个就是集群pod内部的dns服务器
  • CoreDNS 的 DNS 纪录完全泉源于 Service（以及 Pod、Endpoint 等资源）：
  • 为什么必要呢？

    • svc的假造ip难记
    • 一个服务多个端口的时间难以区分
    • 跨ns的时间调用困难，必要知道对方的clusterip
    • 可以直接通过域名的方式来举行访问，差别名称空间下面也可以举行访问
    • 就不必要关系clusterip的厘革，由于删除clusterip的话，ip地点会变动

  • core-dns为每一个创建的svc主动天生一个唯一的域名，也就是dns纪录，每一个svc都在上面举行注册了，一个域名剖析器

    • 域名的格式为 svcname.nsname.svc.cluster.local
    • 服务名称.名称空间.范例.集群域

  • kube-dns已经没有被维护了，大多数利用的是core-dns
1、检察集群dns

检察集群dns
  1. # 查看集群dns 10.96.0.10
  2. [root@master01 ~]# kubectl get svc -n kube-system
  3. NAME       TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)                  AGE
  4. kube-dns   ClusterIP   10.96.0.10   <none>        53/UDP,53/TCP,9153/TCP   7d5h
  6. # pod里面的dns也是10.96.0.10
  7. root@web1-8fd498dd-nch98:/# cat /etc/resolv.conf
  8. nameserver 10.96.0.10
  9. search default.svc.cluster.local svc.cluster.local cluster.local
  10. options ndots:5
  12. # 查看core-dns，集群现在就是这2个pod在提供dns服务
  13. [root@master01 ~]# kubectl get pod -n kube-system  -o wide | grep dns
  14. coredns-665d974787-46d59                   1/1     Running   11             7d6h   
  15. coredns-665d974787-s564k                   1/1     Running   11             7d6h
复制代码

  • 上面不是说kube-dns没有被维护了，为什么照旧利用kube-dns呢？

    • 转发到kube-dns，末了照旧转发到core-dns的pod了
    • 照旧在利用core-dns

  1. # 查看kube-dns的详细信息
  3. [root@master01 ~]# kubectl describe svc -n kube-system kube-dns  | grep -i endpoints
  4. Endpoints:         10.255.112.164:53,10.255.112.165:53
  5. Endpoints:         10.255.112.164:53,10.255.112.165:53
  6. Endpoints:         10.255.112.164:9153,10.255.112.165:9153
  8. # 发现转发到后端的pod是core-dns
  10. [root@master01 ~]# kubectl get pod -n kube-system  -o wide | grep dns
  11. coredns-665d974787-46d59                   1/1     Running   11             7d6h   10.255.112.164   master01   <none>           <none>
  12. coredns-665d974787-s564k                   1/1     Running   11             7d6h   10.255.112.165   master01   <none>           <none>
复制代码
2、pod之间通过域名来访问


  • 域名剖析同一个名称空间下
  1. # 我们上面创建了一个web1 svc，关联了2个pod
  3. # 因此创建一个临时容器测试一下
  5. [root@master01 svc]# kubectl run b1 --image=busybox --rm -ti -- sh
  7. / # wget web1  # 直接访问web1服务，不需要知道web1的svc的ip地址，因为有dns记录，会自动的解析
  8. Connecting to web1 (10.110.146.0:80)
  9. saving to 'index.html'
  10. index.html           100% |**********************************|     4  0:00:00 ETA
  11. 'index.html' saved
  12. / # cat index.html
  13. 123
  15. # busybox会自己去找dns，然后解析这个web1的ip,从而实现访问，就是在访问clusterip,从而获取提供的服务
复制代码

  • 域名剖析不在同一个名称空间下面
  1. # 在test空间下，创建一个pod，测试能不能解析default下的svc
  3. [root@master01 svc]# kubectl run b1 --image=busybox --namespace test  --rm -ti -- sh
  5. # 直接解析svc，没有成功
  6. / # wget web1
  7. wget: bad address 'web1'
  9. # 添加一个defaul空间，就能解析成功
  10. / # wget web1.default
  11. Connecting to web1.default (10.110.146.0:80)
  12. saving to 'index.html'
  13. index.html           100% |**********************************|     4  0:00:00 ETA
  14. 'index.html' saved
  16. # 这个是dns的地址
  18. / # cat /etc/resolv.conf
  19. nameserver 10.96.0.10
  20. search test.svc.cluster.local svc.cluster.local cluster.local
  21. options ndots:5
复制代码

  • 尚有一个题目,pod可以访问差别空间下的pod，直接利用ip访问
  1. / # ping 10.246.73.145
  2. PING 10.246.73.145 (10.246.73.145): 56 data bytes
  3. 64 bytes from 10.246.73.145: seq=0 ttl=63 time=0.093 ms
复制代码

  • 这是是由于不必要dns剖析，直接走的calico网络，pod网络是扁平化的
  • 无论pod在哪一个ns，ip段都是互通的
  • 没有ns的网络隔离(除非利用网络计谋,上一篇博客讲了的)
  • coredns的设置
  1. [root@master01 ~]# kubectl get configmaps -n kube-system coredns -o yaml
  2. apiVersion: v1
  3. data:
  4.   Corefile: |
  5.     .:53 {  # 监听所有dns的请求
  6.         errors
  7.         health {
  8.            lameduck 5s
  9.         }
  10.         ready
  11.         kubernetes cluster.local in-addr.arpa ip6.arpa {
  12.            pods insecure   # 允许pod ip解析pod的名称
  13.            fallthrough in-addr.arpa ip6.arpa
  14.            ttl 30  # dns记录缓存30s
  15.         }
  16.         prometheus :9153
  17.         forward . /etc/resolv.conf {  # 非集群域名(baidu.com0)转发到上游的dns，也就是宿主机配置的dns
  18.            max_concurrent 1000
  19.         }
  20.         cache 30
  21.         loop
  22.         reload
  23.         loadbalance
  24.     }
  25. kind: ConfigMap
  26. metadata:
  27.   creationTimestamp: "2026-03-24T04:41:18Z"
  28.   name: coredns
  29.   namespace: kube-system
  30.   resourceVersion: "302"
  31.   uid: 9281803b-4bfe-4a36-8796-ef60d870e801
复制代码
3、无头的clusterip


  • 也就是svc没有clusterip的ip地点
  • 实用的场景，三个pod，一个主mysql,2个都是备mysql,只要主继续哀求，由于clusterip是轮询的，以是不可，必要headless clsuterip
  • 连合这个dns，statefulset(有序的) 常连合一起利用，为每一个pod分配一个唯一的域名，如许就能指定访问一个pod，不会轮询了
  • 在这种情况下可以通过访问pod的域名来实现访问，其他情况下都是通过访问svc实现对pod的访问
  1. [root@master01 svc]# cat ds.yml
  2. apiVersion: v1
  3. kind: Service
  4. metadata:
  5.   name: nginx
  6. spec:
  7.   clusterIP: None   # 为none就是没有clusterip
  8.   selector:
  9.      app: d1
  10.   ports:
  11.     - port: 80
  12.       targetPort: 80
  13. ---
  14. apiVersion: apps/v1
  15. kind: StatefulSet  # sts的控制器
  16. metadata:
  17.   creationTimestamp: null
  18.   labels:
  19.     app: d1
  20.   name: d1
  21. spec:
  22.   replicas: 2
  23.   selector:
  24.     matchLabels:
  25.       app: d1
  26.   serviceName: "nginx"  # 指定服务，这个服务关联一组pod，dns为每一个这样的pod分配唯一的域名，因为没有clusterip，所以这样
  27.   template:
  28.     metadata:
  29.       creationTimestamp: null
  30.       labels:
  31.         app: d1
  32.     spec:
  33.       containers:
  34.       - image: nginx
  35.         name: nginx
  36.         ports:
  37.         - containerPort: 80
  39. # 创建一个测试容器
  40. [root@master01 ~]# kubectl run b1 --image=busybox    --rm -ti -- sh
  42. # 解析这个nginx svc 返回的是一组pod的域名和ip
  43. / # nslookup nginx
  44. Server:                10.96.0.10
  45. Address:        10.96.0.10:53
  47. ** server can't find nginx.cluster.local: NXDOMAIN
  49. Name:        nginx.default.svc.cluster.local
  50. Address: 10.246.73.150
  51. Name:        nginx.default.svc.cluster.local
  52. Address: 10.244.59.198
  54. # 可以单独访问指定的pod
  56. / # ping d1-0.nginx.default.svc.cluster.local
  57. PING d1-0.nginx.default.svc.cluster.local (10.246.73.150): 56 data bytes
  58. 64 bytes from 10.246.73.150: seq=0 ttl=63 time=0.054 ms
复制代码
4、core-dns和svc的关系


  • 图自己修改一劣等一下
  • 就是在集群中创建一个svc，kueb-proxy会天生ipvs规则大概iptables规则
  • 然后这个core-dns监听svc，会纪录在内里，并有dns纪录


  • pod通过域名访问

    • 起首找自己的dns,也就是core-dns
    • 通过这个dns找到了这个域名对应的ip
    • 然后访问这个pod即可，内核照旧kube-proxy实现的

  1. Service        提供稳定的访问入口（IP + 端口）        餐厅的实体店面
  2. CoreDNS        提供服务名到 IP 的映射        餐厅的地图导航
  3. kube-proxy        实现流量的负载均衡和转发        餐厅的服务员和调度
复制代码
3、变量的方式

4、NodePort


  • 之前的clusterip是集群内部举行访问的，集群外貌就不可了
  • nodeport就是做一个端口映射的，访问物理主机+映射到主机的端口就能访问到集群内部的服务了
  • 创建出来后，每个物理主机都有这个端口，因此每一个主机+映射的端口就能访问
  • 默认天生一个3w以上的端口
  • 寻常的svc利用ipvs全节点转发,kube-proxy在全部节点都创建了ipvs转发规则

    • 为什么全部节点都能访问呢？

      • 缘故起因就是这个externalTrafficPolicy: Cluster这个参数， 全部节点都能转发
      • 这个是控制外部流量怎么访问集群
      • 尚有一个local就是只有当地有pod，才气被访问，背面ingress 会详细讲授的，就是为什么其他节点没有ingress pod就访问不到了？


  • 核心就是添加一个ipvs规则大概iptables规则
  • nodeport访问流程

    • 先访问主机ip+端口
    • 转发到svc的ip+端口
    • kube-proxy通过ipvs规则，转发到后端的关联的pod，从而实现访问

  1. kubectl expose deployment web1 --name nginx-svc --port 80 --target-port 80 --type NodePort
  3. [root@master01 svc]# kubectl get svc
  4. NAME         TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
  5. kubernetes   ClusterIP   10.96.0.1        <none>        443/TCP        7d6h
  6. nginx-svc    NodePort    10.109.165.192   <none>        80:30108/TCP   49s
  7. web1         ClusterIP   10.110.146.0     <none>        80/TCP         93m
  9. # 所有节点都有这个映射的端口
  10. [root@master02 ~]# netstat -pant|grep 30108
  11. tcp        0      0 0.0.0.0:30108           0.0.0.0:*               LISTEN      2315/kube-proxy  
  13. curl 192.168.50.20:30108
  14. curl 192.168.50.21:30108
  15. curl 192.168.50.22:30108
  17. # 查看ipvs信息
  18. ipvsadm -ln
  20. TCP  10.255.112.128:30108 rr
  21.   -> 10.244.59.199:80             Masq    1      0          0         
  22.   -> 10.246.73.152:80             Masq    1      0          0      
复制代码
5、ingress(最常用的)


  • 上面的几种方式都是四层，基于ip和端口的
  • ingress是基于七层的
  • 让用户通过一个域名/ip,访问集群内里多个差别的svc
  • 是一个七层的路由，可以或许根据域名和url路径转发
1、核心组件


  • ingress资源

    • 访问a.com 转发给svc1
    • 访问b.com/api 转发到svc2

  • ingress controller

    • 是真正干活的步调(nginx-ingress)
    • 监听全部ingress规则(自己编写的ingress规则)
    • 主动天生设置并见效，就是天生nginx.conf文件，翻译成这个
    • 吸收外部真实流量

2、工作流程


  • 用于输入域名，访问ingress的外部ip/域名
  • 流量到达ingress-controller这个pod

    • 默认监听是80/443
    • 一样寻常是nodeport

  • 根据ingress规则匹配

    • 域名是谁
    • url路径是谁
    • 转发到哪一个svc

  • 转发到svc和关联的pod上
  • 末了照旧靠的ipvs转发到对应的pod
3、安装ingress


  • https://github.com/kubernetes/ingress-nginx
  • https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.6.4/deploy/static/provider/cloud/deploy.yaml
  • 上面这个文件，路径在deploy/static/下面
  1. # 将里面三个镜像可以改成华为的
  3. kubectl apply -f ingress.yml
  5. [root@master01 svc]# kubectl get pod -n ingress-nginx
  6. NAME                                        READY   STATUS      RESTARTS   AGE
  7. ingress-nginx-admission-create-dqrkj        0/1     Completed   0          65s
  8. ingress-nginx-admission-patch-pjbf5         0/1     Completed   0          65s
  9. ingress-nginx-controller-8478d55789-f4444   1/1     Running     0          65s
  11. # 查看svc
  12. [root@master01 svc]# kubectl get svc -n ingress-nginx
  13. NAME                                 TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)                      AGE
  14. ingress-nginx-controller             LoadBalancer   10.103.125.75   <pending>     80:32162/TCP,443:30717/TCP   70s
  15. ingress-nginx-controller-admission   ClusterIP      10.111.38.80    <none>        443/TCP                      70s
  17. # 将这个ingress-nginx-controller改成nodeport
  18. # 直接修改配置文件即可
  19. [root@master01 svc]# kubectl get svc -n ingress-nginx
  20. NAME                                 TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)                      AGE
  21. ingress-nginx-controller             NodePort    10.103.125.75   <none>        80:32162/TCP,443:30717/TCP   3m46s
  22. ingress-nginx-controller-admission   ClusterIP   10.111.38.80    <none>        443/TCP                      3m46s
复制代码
4、界说ingress规则


  • 实验图


  • ingress实验流程就是

    • 访问节点ip+32162，这个svc，根据这个ipvs规则(创建了一个svc，kube-proxy会主动创建一个ipvs规则)，转发到ingress-nginx-controller这个pod
    • 根据这ingress这个规则，转发到提供服务的svc
    • 根据这个ipvs规则转发到后端的pod

  1. # class为nginx
  2. [root@master01 svc]# kubectl get ingressclasses.networking.k8s.io
  3. NAME    CONTROLLER             PARAMETERS   AGE
  4. nginx   k8s.io/ingress-nginx   <none>       11m
  6. [root@master01 svc]# cat in.yml
  7. apiVersion: networking.k8s.io/v1
  8. kind: Ingress
  9. metadata:
  10.   name: my-app-ingress
  11. spec:
  12.   ingressClassName: nginx   # 需要定义class规则，对一组ingress
  13.   rules:
  14.   - host: www.meme1.com
  15.     http:
  16.       paths:
  17.       - path: / # 直接匹配根路径
  18.         pathType: Prefix  # 前缀匹配
  19.         backend:
  20.           service:
  21.             name: svcn1   # 转发到svcn1的80端口，从而转发到后端的pod
  22.             port:
  23.               number: 80
  25.   - host: www.meme2.com
  26.     http:
  27.       paths:
  28.       - path: /
  29.         pathType: Prefix
  30.         backend:
  31.           service:
  32.             name: svcn2
  33.             port:
  34.               number: 80
  36. # 创建svcn1和svcn2
  38. [root@master01 svc]# cat web1.yml
  39. apiVersion: v1
  40. kind: Service
  41. metadata:
  42.   name: svcn1
  43. spec:
  44.   type: NodePort
  45.   selector:
  46.     app: svcn1
  47.   ports:
  48.   - port: 80
  49.     targetPort: 80
  50.     nodePort: 32222
  51. ---
  52. apiVersion: apps/v1
  53. kind: Deployment
  54. metadata:
  55.   creationTimestamp: null
  56.   labels:
  57.     app: svcn1
  58.   name: web1
  59. spec:
  60.   replicas: 1
  61.   selector:
  62.     matchLabels:
  63.       app: svcn1
  64.   strategy: {}
  65.   template:
  66.     metadata:
  67.       creationTimestamp: null
  68.       labels:
  69.         app: svcn1
  70.     spec:
  71.       containers:
  72.       - image: nginx
  73.         name: nginx
  74.         ports:
  75.         - containerPort: 80
  76.         resources: {}
  78. [root@master01 svc]# kubectl get pod
  79. NAME                   READY   STATUS    RESTARTS   AGE
  80. web1-5b7f5548b-vx9vt   1/1     Running   0          23m
  81. web2-d86c55fbf-2mm2b   1/1     Running   0          21m
  83. [root@master01 svc]# kubectl get svc
  84. NAME         TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
  85. kubernetes   ClusterIP   10.96.0.1       <none>        443/TCP        7d8h
  86. svcn1        NodePort    10.101.227.56   <none>        80:32222/TCP   23m
  87. svcn2        NodePort    10.108.20.222   <none>        80:32223/TCP   22m
复制代码
  1. # 部署ingress规则
  2. [root@master01 svc]# kubectl get ingress
  3. NAME             CLASS   HOSTS                         ADDRESS         PORTS   AGE
  4. my-app-ingress   nginx   www.meme1.com,www.meme2.com   10.103.125.75   80      21m
  6. # 已经做好了映射了
  7. [root@master01 svc]# kubectl describe ingress
  8. Name:             my-app-ingress
  9. Labels:           <none>
  10. Namespace:        default
  11. Address:          10.103.125.75
  12. Default backend:  default-http-backend:80 (<error: endpoints "default-http-backend" not found>)
  13. Rules:
  14.   Host           Path  Backends
  15.   ----           ----  --------
  16.   www.meme1.com  
  17.                  /   svcn1:80 (10.246.73.160:80)
  18.   www.meme2.com  
  19.                  /   svcn2:80 (10.246.73.159:80)
  20. Annotations:     <none>
  21. Events:
  22.   Type    Reason  Age                From                      Message
  23.   ----    ------  ----               ----                      -------
  24.   Normal  Sync    21m (x2 over 21m)  nginx-ingress-controller  Scheduled for sync
复制代码
5、客户端欣赏器测试和细节
  1. [root@master01 svc]# curl -H "Host: www.meme1.com" http://192.168.50.22:32162
  2. meme1.com
  3. [root@master01 svc]# curl -H "Host: www.meme2.com" http://192.168.50.22:32162
  4. meme2
  6. # 只能访问22才能访问到，原因就是20,21节点上面没有这个ingress-nginx这个pod
  8. # 访问20:32162 没有这个pod，进不去，也没有这ipvs
  9. # 21一样
  11. # 因此将这个副本数变成3个即可
  12. [root@master01 svc]# kubectl scale deployment ingress-nginx-controller -n ingress-nginx --replicas=3
  14. # 就能访问了，也有这个ipvs规则了
复制代码

  • 上面的实验，为什么21,20的32162不能访问呢？

    • 缘故起因就是ingress-nginx这个svc中的externalTrafficPolicy: Local 是这个模式

      • 这个模式下，当地有ingresss pod ，该节点的ipvs才有后端，能访问
      • 当地没有ingress pod ,该节点的ipvs没有后端，访问拒绝

    • 摆设3个ingrees pod 后，一个在master02上，一个在node上
    • 这2个节点都能访问到，master01上有污点，以是不能摆设，也就没有ipvs后端，也就访问不到了

  • 总结一下

    • 由于ingress的svc是local,这个节点上有这个ingress的pod，才气实现访问节点(有ingress的节点)+端谈锋气访问到，其他节点上没有这个ingress的pod，就访问不到，有ingress pod的节点就有转发到ingree pod的规则
    • 这个nodeport的svc不能实现跨节点的通讯
    • 改成externalTrafficPolicy: cluster就能访问到了，这个就是无论节点上有没有这个ingress pod，都能访问，就天生了ipvs规则，到这个ingress pod的规则

  • 上面不通，除了摆设多个ingrees pod 外，尚有一种方式就是将loacl改成cluster,如许不管其他节点有没有ingress pod 都能访问到了
  1. [root@master01 svc]# kubectl edit svc -n ingress-nginx ingress-nginx-controller
  3. externalTrafficPolicy: Cluster
  5. # 修改后，ipvs规则就有了，对应的是3个ingress pod ,因为流量必须经过这个ingrees pod 然后根据这个ingress规则实现转发
  7. TCP  192.168.50.20:32162 rr
  8.   -> 10.244.59.201:80             Masq    1      0          0         
  9.   -> 10.246.73.162:80             Masq    1      0          0         
  10.   -> 10.246.73.163:80             Masq    1      0          1      
复制代码
6、ingress规则详细设置
  1. apiVersion: networking.k8s.io/v1
  2. kind: Ingress
  3. metadata:
  4.   name: my-ingress
  5.   namespace: default
  6.   annotations:
  7.     # 最重要的注解（rewrite、限流、超时都在这里）
  8.     nginx.ingress.kubernetes.io/rewrite-target: /  # 路径重写，/api/v1 转发到 / 就是只访问根目录
  9. spec:
  10.   # 指定 Ingress 控制器（必须写）
  11.   ingressClassName: nginx
  12.   
  13.   # 路由规则（核心！）
  14.   rules:
  15.   - host: www.meme1.com   # 访问域名
  16.     http:  # 因为是七层的，所以是http访问
  17.       paths:
  18.       - path: /           # URL 路径
  19.         pathType: Prefix  # 匹配类型
  20.         backend:  # 将符合上面的规则转发到哪一个svc上
  21.           service:
  22.             name: svcn1   # 转发到哪个 Service
  23.             port:
  24.               number: 80  # Service 端口
  26.   - host: www.meme2.com
  27.     http:
  28.       paths:
  29.       - path: /
  30.         pathType: Prefix
  31.         backend:
  32.           service:
  33.             name: svcn2
  34.             port:
  35.               number: 80
复制代码

  • pathType详解

    • Prefix 前缀匹配，/匹配全部的，/api 匹配/api/，/api/v1, /api/user
    • Exact 准确匹配，必须完全一样即可， /api 不匹配/api/

  • 只必要访问根目次 添加一个表明即可
  1. annotations:
  2.   nginx.ingress.kubernetes.io/rewrite-target: /
复制代码
7、ingress进阶实验


  • 同一个域名差别的路径转发到差别的服务
  • 访问a.com/v1 跳转到v1服务
  • 访问a.com/v2 跳转到v2 服务
  1. [root@master01 svc]# cat in1.yml
  2. apiVersion: networking.k8s.io/v1
  3. kind: Ingress
  4. metadata:
  5.   name: ingress-1
  6.   annotations:
  7.     nginx.ingress.kubernetes.io/rewrite-target: /
  8. spec:
  9.   ingressClassName: "nginx"
  10.   rules:
  11.   - host: "a.com"
  12.     http:
  13.       paths:
  14.       - path: /v1
  15.         pathType: Prefix
  16.         backend:
  17.           service:
  18.             name: v1
  19.             port:
  20.               number: 80
  21.   - host: "a.com"
  22.     http:
  23.       paths:
  24.       - path: /v2  # a.com/v2 由于是nginx的配置(这个配置会翻译成nginx的配置)
  25.                    # a.com/v2 会跳转到 /usr/share/nginx/html/v1/index.html 这个页面
  26.         pathType: Prefix
  27.         backend:
  28.           service:
  29.             name: v2
  30.             port:
  31.               number: 80
  33. [root@master01 svc]#  kubectl describe ingress ingress-1
  34. Name:             ingress-1
  35. Labels:           <none>
  36. Namespace:        default
  37. Address:          10.103.125.75
  38. Default backend:  default-http-backend:80 (<error: endpoints "default-http-backend" not found>)
  39. Rules:
  40.   Host        Path  Backends
  41.   ----        ----  --------
  42.   a.com      
  43.               /v1   v1:80 (10.246.73.166:80)
  44.   a.com      
  45.               /v2   v2:80 (10.246.73.167:80)
  46. Annotations:  nginx.ingress.kubernetes.io/rewrite-target: /
  47. Events:
  48.   Type    Reason  Age                From                      Message
  49.   ----    ------  ----               ----                      -------
  50.   Normal  Sync    11m (x4 over 29m)  nginx-ingress-controller  Scheduled for sync
  51.   Normal  Sync    11m (x4 over 29m)  nginx-ingress-controller  Scheduled for sync
  52.   Normal  Sync    11m (x4 over 29m)  nginx-ingress-controller  Scheduled for sync
复制代码

  • 客户端测试
  1. [root@master01 svc]# curl -H "Host: a.com" http://192.168.50.22:32162/v1
  2. v1
  3. [root@master01 svc]# curl -H "Host: a.com" http://192.168.50.22:32162/v2
  4. v2
复制代码

  • ingress 只负责转发，不负责修改路径
  • 第一种在pod内里创建v2,v1目次，存放网页文件
  • 第二种，路径重写，跳转到/目次即可
  1.   annotations:
  2.     nginx.ingress.kubernetes.io/rewrite-target: /
复制代码
8、ingress总结


  • 负责路径的转发，这个设置会翻译成nginx的设置，雷同的，不会修改路径
  • 这个访问路径必须真实存在，才气访问到
6、LoadBalance

1、loadbalance是什么呢？


  • 之前学过的nodeport，必要袒露端口，3w以上的，不方便，访问必要加上端口
  • loadbalance直接分配一个公网ip，直接对外提供服务

    • lb=nodeport + 云厂商的外部负载均衡器

  • 由于我没有公网ip，因此必要下载一个插件，模拟一下即可
  1. # 这个external-ip 这个就是公网ip地址,没有指定，就是none
  2. [root@master01 wordpress]# kubectl get svc
  3. NAME         TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
  4. kubernetes   ClusterIP   10.96.0.1    <none>        443/TCP   15d
复制代码
2、下载插件文件
  1. [root@master01 lb]# wget https://raw.githubusercontent.com/metallb/metallb/v0.13.9/config/manifests/metallb-native.yaml
  3. [root@master01 lb]# kubectl apply -f metallb-native.yaml
  5. [root@master01 lb]# kubectl get pod -n metallb-system
  6. NAME                         READY   STATUS    RESTARTS   AGE
  7. controller-7967ffcf8-h29sm   1/1     Running   0          6m15s
  8. speaker-btw9v                1/1     Running   0          6m15s
  9. speaker-lt2h6                1/1     Running   0          6m15s
  10. speaker-rvslq                1/1     Running   0          6m15s
复制代码
3、创建地点池和绑定
  1. # 安装一个网络计算工具
  2. yum -y install sipcalc
  4. [root@k-master svc]# sipcalc 192.168.50.100/24
  5. -[ipv4 : 192.168.50.100/24] - 0
  7. [CIDR]
  8. Host address                - 192.168.50.100
  9. Host address (decimal)        - 3232248420
  10. Host address (hex)        - C0A83264
  11. Network address                - 192.168.50.0
  12. Network mask                - 255.255.255.0
  13. Network mask (bits)        - 24
  14. Network mask (hex)        - FFFFFF00
  15. Broadcast address        - 192.168.50.255
  16. Cisco wildcard                - 0.0.0.255
  17. Addresses in network        - 256
  18. Network range                - 192.168.50.0 - 192.168.50.255
  19. Usable range                - 192.168.50.1 - 192.168.50.254
复制代码
  1. # 创建地址池
  3. [root@k-master svc]# cat pools.yaml
  4. apiVersion: metallb.io/v1beta1
  5. kind: IPAddressPool
  6. metadata:
  7.   name: first-pool
  8.   namespace: metallb-system
  9. spec:
  10.   addresses:
  11.   - 192.168.50.200-192.168.50.220
  13. # 创建实例绑定地址池
  14. [root@k-master svc]# cat l2.yaml
  15. apiVersion: metallb.io/v1beta1
  16. kind: L2Advertisement
  17. metadata:
  18.   name: example
  19.   namespace: metallb-system
  20. spec:
  21.   ipAddressPools:
  22.   - first-pool
  24. [root@k-master svc]# kubectl get ipaddresspools.metallb.io  -n metallb-system
  25. NAME         AUTO ASSIGN   AVOID BUGGY IPS   ADDRESSES
  26. first-pool   true          false             ["192.168.50.200-192.168.50.220"]
复制代码
4、创建svc
  1. # 因为是LoadBalancer，所以会自动的分配外部ip地址，从之前创建的地址池中分配一个地址
  2. # 如果是对外提供的，就需要使用公网ip
  3. # 还会创建一个nodeport端口
  4. [root@k-master svc]# kubectl expose deployment nginx --name svc666 --port 80 --target-port 80 --type LoadBalancer
  5. service/svc666 exposed
  6. [root@k-master svc]# kubectl get svc
  7. NAME         TYPE           CLUSTER-IP     EXTERNAL-IP      PORT(S)        AGE
  8. kubernetes   ClusterIP      10.96.0.1      <none>           443/TCP        17d
  9. svc666       LoadBalancer   10.99.233.85   192.168.50.200   80:31439/TCP   3s
  11. # 直接访问ip即可，但是这个80端口如果换成其他的81，就需要加上端口了
复制代码
5、lb访问原理


  • 直接访问公网ip地点
  • 哀求到达集群节点的nodeport端口
  • 根据haproxy实现的ipvs规则转发到后端的pod
  • Nginx pod 相应
  • 公网ip+NodePort
6、lb访问
  1. # 直接访问这个模拟出来的公网ip地址就能访问到后端关联的pod
  2. # 不需要添加端口
  3. # 如果购买了域名的话，可以使用域名访问
  5. [root@k-master svc]# curl 192.168.50.200  # 等价于 :80
  6. <!DOCTYPE html>
  7. <html>
  8. <head>
  9. <title>Welcome to nginx!</title>
  11. </head>
  12. <body>
  13. <h1>Welcome to nginx!</h1>
  14. <p>If you see this page, the nginx web server is successfully installed and
  15. working. Further configuration is required.</p>
  17. <p>For online documentation and support please refer to
  18. nginx.org.<br/>
  19. Commercial support is available at
  20. nginx.com.</p>
  22. <p><em>Thank you for using nginx.</em></p>
  23. </body>
  24. </html>
复制代码
7、实验


  • wordpress和mysql

    • mysql和wordpress内部通讯,dns大概clusterip  wordpress访问mysql-svc就能访问到mysql
    • 外部访问wordpress，利用nodeport

1、创建mysql的pod和svc
  1. [root@master01 wordpress]# kubectl run db --image=mysql --image-pull-policy=IfNotPresent --dry-run=client -o yaml > db.yml
  3. [root@master01 wordpress]# cat db.yml
  4. apiVersion: v1
  5. kind: Pod
  6. metadata:
  7.   creationTimestamp: null
  8.   labels:
  9.     run: db
  10.   name: db
  11. spec:
  12.   nodeName: node  # 指定调度在node节点上
  13.   containers:
  14.   - image: mysql
  15.     imagePullPolicy: IfNotPresent
  16.     name: db
  17.     resources: {}
  18.     env:
  19.     - name: "MYSQL_ROOT_PASSWORD"  # 添加环境变量
  20.       value: "123"
  21.     - name: "MYSQL_DATABASE"
  22.       value: "wordpress"
  23.   dnsPolicy: ClusterFirst
  24.   restartPolicy: Always
  26. [root@master01 wordpress]# kubectl expose pod db --type ClusterIP --port=3306 --target-port 3306  --name db-svc --dry-run=client -o yaml > db-svc.yml
  28. [root@master01 wordpress]# cat db-svc.yml
  29. apiVersion: v1
  30. kind: Service
  31. metadata:
  32.   creationTimestamp: null
  33.   labels:
  34.     run: db
  35.   name: db-svc
  36. spec:
  37.   ports:
  38.   - port: 3306
  39.     protocol: TCP
  40.     targetPort: 3306
  41.   selector:
  42.     run: db
  43.   type: ClusterIP
  45. [root@master01 wordpress]# kubectl get pod,svc
  46. NAME     READY   STATUS    RESTARTS   AGE
  47. pod/db   1/1     Running   0          8m31s
  49. NAME                 TYPE        CLUSTER-IP    EXTERNAL-IP   PORT(S)    AGE
  50. service/db-svc       ClusterIP   10.101.1.39   <none>        3306/TCP   5m50s
  51. service/kubernetes   ClusterIP   10.96.0.1     <none>        443/TCP    15d
复制代码
集群内部访问
  1. # 可以直接通过ClusterIP进行访问对应的pod
  2. [root@master01 wordpress]# mysql -uroot -p123 -h 10.101.1.39
  4. # 访问svc就能访问到对应的pod
复制代码
2、创建wordpress和svc
  1. kubectl run web-wordpress --image=wordpress --image-pull-policy=IfNotPresent --dry-run=client -o yaml > web.yml
  3. [root@master01 wordpress]# cat web.yml
  4. apiVersion: v1
  5. kind: Pod
  6. metadata:
  7.   creationTimestamp: null
  8.   labels:
  9.     run: web-wordpress
  10.   name: web-wordpress
  11. spec:
  12.   nodeName: master02
  13.   containers:
  14.   - image: wordpress
  15.     imagePullPolicy: IfNotPresent
  16.     name: web-wordpress
  17.     resources: {}
  18.     env:
  19.     - name: "WORDPRESS_DB_HOST"  # 连接后端数据的地址，这里使用的是svc，也可以使用svc的dns地址，这样svc的ip变化后，也不受影响，db-svc.default.svc.cluster.local
  20.       value: "10.101.1.39"
  21.     - name: "WORDPRESS_DB_USER"  # 数据库的用户
  22.       value: "root"
  23.     - name: "WORDPRESS_DB_PASSWORD"  # 数据库的密码
  24.       value: "123"
  25.     - name: "WORDPRESS_DB_NAME"  # 使用哪一个数据库
  26.       value: "wordpress"
  27.   dnsPolicy: ClusterFirst
  29. kubectl expose pod web-wordpress --type NodePort --port 80 --target-port 80 --name web-svc --dry-run=client -o yaml > web-svc.yml
  31. [root@master01 wordpress]# kubectl get pod
  32. NAME            READY   STATUS    RESTARTS   AGE
  33. db              1/1     Running   0          19m
  34. web-wordpress   1/1     Running   0          6m8s
  35. [root@master01 wordpress]# kubectl get svc
  36. NAME         TYPE        CLUSTER-IP    EXTERNAL-IP   PORT(S)        AGE
  37. db-svc       ClusterIP   10.101.1.39   <none>        3306/TCP       17m
  38. kubernetes   ClusterIP   10.96.0.1     <none>        443/TCP        15d
  39. web-svc      NodePort    10.98.68.65   <none>        80:31366/TCP   4m20s
复制代码

  • 欣赏器访问
  1. 192.168.50.20:31366
复制代码

  • 这个实验实现了什么呢？

    • pod与pod之间的通讯，可以通过ip,svc(svc对应后端的pod),大概svc的dns通讯
    • 这个wordpress的svc利用的是NodePort,对外提供服务的

svc中nodeport核心参数

字段管谁的流量可选项作用externalTrafficPolicy外部流量（你 curl 节点 IP）Cluster / Local控制外部访问要不要跨节点internalTrafficPolicy内部流量（Pod 访问 Service）Cluster / Local控制内部访问要不要跨节点

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

×
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

登录后关闭弹窗

登录参与点评抽奖  加入IT实名职场社区
去登录

QQ|手机版|qidao123.com IT社区;IT企服评测▪应用市场 ( 浙ICP备20004199|浙ICP备20004199号 )|网站地图

GMT+8, 2026-9-30 00:43 , Processed in 0.024888 second(s), 6 queries , Redis On.

Powered by Discuz! X3.5 Licensed

© 2001-2026 Discuz! Team.

快速回复 返回顶部 返回列表