CF-926

两点睡，七点起，阎王夸我好身体……

主要这场实在是难绷，两个小时都在C题上吊死了，也不是没想过跳题，只是后面的题我更是一点思路都没有-^-

“就喜欢这种被揭穿的感觉，爽！”

B

分析

​ 涂色的单元格能够包含
k种
对角线，很明显要根据图像的具体性质想答案：

然而我赛时是一股脑地猜结论，这种方法在赛时不确定性还是太大了，希望自己能尽快把思维这方面的短板补起来……

​ 上色时考虑单种特殊点对其它特殊点及答案的贡献。

• 四个顶点
  ：作图发现只有同侧的两个顶点对答案的贡献是2，另外两个是1；再分析发现，顶点包含的是一条最短和一条最长的对角线，前者只经过它自己，后者还要经过（n-1）个格子，所以上色一个顶点后会使（n-1）个处于最长对角线上的格子贡献-1
• 中心点或者说不在边缘位置的点
  ：对他们上色就会使经过它们包含的两种对角线的格子贡献-1——其中包括处于顶点，非边缘位置的点，边缘位置的格子
• 边缘位置的点
  ：对他们上色就会使处于非边缘位置的格子贡献-1

​ 要使答案最小，我们
涂色的格子的贡献一定尽量都是2
，若贡献为2的格子涂完了再考虑贡献为1的格子，再结合上面三种点位的性质，我们发现
涂顶点与边缘位置的格子
才会使可选格子贡献值最大（涂色不在边缘位置的格子影响的格子数更多，涂它们比不涂它们会使贡献为2的格子更少）。由此再考虑使涂色这两种格子对其它格子影响最小，
先涂的格子一定都在同一侧，有n个，而其余贡献为2的格子是对侧的边缘位置的格子，有(n-2)个
，剩下的可选格子贡献都为1。

比如图示3*3的红色部分

操作

​ 因此，有w=(n*2-2)个格子贡献为2，
(w乘2)>=k时，答案为(k/2)向上取整
，否则，还要涂k-(w乘2)个贡献为1的格子，
答案为k-(w乘2)+w=k-w
。

为了规避markdown语法……

代码

#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define int long long
#define db(x) cout<<x<<" "<<endl;
#define _db(a,n) for(int i=1;i<=n;i++) cout<<a[i]<<" ";cout<<endl;
#define mem(a) memset(a,0, sizeof(a))
//int qz(int k){
//	if(k%2==0) return k/2;
//	else return k/2+1;
//}
signed main()
{
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
	int t,n,k,w,ans=0;cin>>t;
	while(t--){
		cin>>n>>k;
		w=n*2-2;
        //身为蒟蒻现在才学会怎么向上取整很合理吧……
		if(w*2>=k) ans=(k+1)/2;//ans=qz(k);
		else ans=k-w;
		cout<<ans<<endl;
	}
	return 0;
}

C

更新中(/头秃)

前言

计算机在人类社会中的地位逐渐上升，已到了不可替代的地位。电竞房里、办公桌上，计算机的身影随处可见。
学会更好的利用电脑，更方便地使用计算机，能够让我们工作的效率更高。
对于计算机这熟悉的工具，我们又了解多少呢？

> 计算机发展历程

>> 历史上的第一部计算机

世界上第一台电子计算机是美国的ENIAC，有差不多两间教室那么大。
这台计算机每秒钟可以进行近5000次加法运算，这在现在算不上什么，但在当时却是破天荒的。

>> 计算机的发展历程上的大人物

1. 法国人约瑟夫·杰夸德发明使用打孔卡(1801);
2. "电脑之父"巴贝基发明分析机;
3. 数学家冯·诺依曼的设计思想起到了关键作用，所以
   冯·诺依曼被称为现代计算机之父
   。

依据计算机所采用电子器件的不同，计算机发展可划分为
电子管
、
晶体管
、
集成电路
、
超大规模集成电路
，一共4代，一代更比一代强。
前面所提到的ENIAC就是电子管计算机。

> 计算机与电脑

日常生活中我们常听到“电脑”二字。其实，
电脑就是计算机的俗称。

> 计算机系统

一个计算机系统应该包括硬件系统部分和软件系统部分。

>> 硬件系统

一般指用电子器件和机电装置组成的计算机实体。

通俗点讲，一切你所看的见摸得着的，就是硬件。
包括：屏幕、键盘、鼠标、摄像头、投影仪、U盘等。

中央处理器（CPU）与内部存储器（Memory）和输入/输出（I/O）设备合称为电子计算机三大核心部件。

中央处理器
（CPU，Central Processing Unit）是一块超大规模的集成电路，是一台计算机的运算核心（Core）和控制核心（Control Unit）。
它的功能主要是解释计算机指令以及处理计算机软件中的数据。
中央处理器主要包括运算器（算术逻辑运算单元，ALU，ArithmeTIc Logic Unit）和高速缓冲存储器（Cache）。

内部存储器
（Memory，又称记忆体），简称内存。
它用于暂时存放CPU中的运算数据，以及与硬盘等外部存储器交换的数据。
它是外存与CPU进行沟通的桥梁，计算机中所有程序的运行都在内存中进行，只要计算机开始运行，操作系统就会把需要运算的数据从内存调到CPU中进行运算，当运算完成，CPU将结果传送出来。
内存的运行决定计算机整体运行快慢，内存性能的强弱影响计算机整体发挥的水平。

输入、输出设备
（IO，in or out）可以理解为外接。
它是一切除中央处理器、内存之外的设备的统称。常见的输入设备有鼠标、键盘;常见的输出设备有屏幕等。

在实际调查中，发现有很多人搞不清楚内存与外存的区别。

内存，简单理解就是你打开手机后台，上面标的4G、8G、16G。程序运行时会往内存读写数据，你可以把内存理解成一个空间，程序运行就是往里边塞东西和取东西。内存空间容量读写速度快，所以放的东西是暂时存放。计算机每一次重新启动都会刷新内存。注意了，在Windows桌面右击刷新是不会刷新内存的，他只是重新加载了桌面图标的图片文件。

手机内存：

外存，其实约等于硬盘，像你手机的128G、256G，也就是
Win+E
进入
文件资源管理器
看见的C盘、D盘。你下载的程序、文件，都会被放到硬盘里，可以做长时间存储。外存的读写速度稍慢于内存。外存既是输入设备，也是输出设备，正好对应了读、写两个操作。

电脑外存：

这里再普及一个概念：磁盘分区
我们所看见的C盘、D盘，其实都是一个磁盘分区。他们属于同一个硬盘，相当于把一个硬盘分成了C盘、D盘等几部分。
其实，我们常用的U盘也是一种移动硬盘，他也可以分区。
Disk Genius
是一款不错的磁盘分区软件。
我看见网上有一些商家帮忙分区的，大家可以不用花这个冤枉钱。当然，如果你是没有经验的小白，那还是谨慎行事吧..数据无价。

>> 软件系统

是指在硬件设备上运行的各种程序以及有关说明资料的总称。

通俗点讲，软件就是让这堆破铜烂铁运行起来的指挥官，它能听得懂人话，根据用户的指示去指挥这台机器去做特定的动作。

一般计算机的软件可粗略分为系统软件和应用软件。

系统软件，例如BIOS、Windows，是指管理、监控和维护计算机资源（包括硬件和软件）的软件。
主要包括操作系统、各种程序设计语言及其解释和编译系统、数据库管理系统等。
后面两个名词不懂可以先不用理解，这涉及到更深的知识，在本系列我会提到，对于日常生活来说粗略了解就行了。

应用软件，是用户利用计算机及其提供的系统软件为解决各类实际问题而编制的计算机程序。
这里的用户是泛指的，指计算机的使用者，对于大部分人来说用的应用软件都不是自己写的，例如微信、QQ。

当然，自己写程序也不是不行。程序可以让计算机自己完成一些机械化的操作，普通使用者也可以学习写一些简单、有用的程序。

总结

The End
Yuito 2023

一、原始代码功能如下，包含两个request接口的调用,耗时情况约4秒

import datetime

import time

import requests



start_time=datetime.datetime.now()

print("开始时间:",start_time)



url= "http://192.168.37.8:7777/api/mytest2"data1=requests.post(url).text

print(data1)

time.sleep(2)



url2= "http://192.168.37.8:7777/api/mytest"data2= requests.get(url2).text

print(data2)

time.sleep(2)



end_time=datetime.datetime.now()

print("结束时间",end_time)

time_need= (end_time -start_time ).seconds

print("耗时豪秒数:",time_need)

耗时约：4秒

二、替换语句，使用session对象，加上session后再调用，优化效果不明显

import datetime

import time

import requests



start_time=datetime.datetime.now()

print("开始时间:",start_time)

session=requests.session()



url= "http://192.168.37.8:7777/api/mytest2"data1=session.post(url).text

print(data1)

time.sleep(2)



url2= "http://192.168.37.8:7777/api/mytest"data2= session.get(url2).text

print(data2)

time.sleep(2)



end_time=datetime.datetime.now()

print("结束时间",end_time)

time_need= (end_time -start_time ).seconds

print("耗时豪秒数:",time_need)

耗时依然是：4秒

三、引入多线程机制，优化效果比较明显
1.定义线程方法
def thread_1():
def thread_2():

2.定义线程
thread1 = threading.Thread(target = thread_1)
thread2 = threading.Thread(target = thread_2)

3.启动线程
thread1.start()
thread2.start()

4.等待线程执行完毕
thread1.join（）
thread2.join（）

其中时间的语句如下：

start_time = datetime.datetime.now()
//
end_time = datetime.datetime.now()
time_need = (end_time - start_time ).seconds

具体的实现如下:

import datetime

import threading

import time

import requests



start_time=datetime.datetime.now()

print("开始时间:",start_time)



def thread_1():

    url= "http://192.168.37.8:7777/api/mytest2"data1=requests.post(url).text

    print(data1)

    time.sleep(2)



def thread_2():

    url2= "http://192.168.37.8:7777/api/mytest"data2= requests.get(url2).text

    print(data2)

    time.sleep(2)





thread1= threading.Thread(target =thread_1)

thread2= threading.Thread(target =thread_2)



thread1.start()

thread2.start()



thread1.join()

thread2.join()



end_time=datetime.datetime.now()

print("结束时间",end_time)

time_need= (end_time -start_time ).seconds

print("耗时豪秒数:",time_need)

耗时确实下降至2秒

服务的发布

发布的方式

之前说过了服务的发现，这个是服务的发布，服务的发布其实就是让你的应用可以被外部访问到，因为如果你的服务外部不可以访问的话那你起这个服务有什么作用呢？没有什么太大的作用是吧
默认情况下，外界是无法访问到集群内的ClusterIP的

1.NodePort

nodePort就是将svc的某个端口与集群的某个端口做了一个映射
通过nodePort映射出去有2种方法

方法一：创建的时候直接指定类型

这种方式比较简单

# 先创建一个nginx的pod
[root@master ~]# kubectl run web01 --image nginx --image-pull-policy IfNotPresent
pod/web01 created
[root@master ~]# kubectl get pods -o wide
NAME    READY   STATUS    RESTARTS   AGE   IP              NODE    NOMINATED NODE   READINESS GATES
web01   1/1     Running   0          6s    10.244.104.13   node2   <none>           <none>

我们可以看到他的IP地址是10.244.104.14，我们使用windows的cmd来ping一下这个地址看看能不能通

我们可以看到这个地址是不通的，既然不通那浏览器也肯动访问不到

我们现在通过nodePort将他映射出去

[root@master ~]# kubectl expose pod web01 --type NodePort --port 80 --target-port 80 
service/web01 exposed
[root@master ~]# kubectl get svc
NAME         TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
kubernetes   ClusterIP   10.96.0.1       <none>        443/TCP        38d
pod01        ClusterIP   10.100.218.31   <none>        80/TCP         4d4h
web01        NodePort    10.102.81.211   <none>        80:31545/TCP   4s

我们可以看到有一个NodePort类型的svc 他也有一个集群内部的IP地址，但是我们要访问的不是这个IP，我们只用看他的端口
他映射的端口是31545，那么这个端口如何使用呢？
这个端口可以跟在集群内的任意一台节点的IP地址后面
比如，这个pod是跑在node02上的，我们可以通过node02的IP地址:31545就可以访问到，或者通过node01的IP地址:31545，当然使用master:31545也是可以的
是不是这样的呢？我们来看看

1. 我们首先通过master的IP地址来访问
   
   可以看到是通的
2. 我们再通过node01的IP地址来访问
   
   使用node01的也是可以的
3. 使用node02的IP地址来访问
   
   也是没有任何的问题
   现在集群内部的nginx就可以被外部访问到了

方法二：在线修改(将其他类型改为NodePort)

我们先将刚刚创建的svc删除，pod保留

[root@master ~]# kubectl expose pod web01 --port 80 --target-port 80 
service/web01 exposed
[root@master ~]# kubectl get svc
NAME         TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)   AGE
kubernetes   ClusterIP   10.96.0.1      <none>        443/TCP   38d
web01        ClusterIP   10.104.17.66   <none>        80/TCP    5s

只要不指定类型，那么默认就是ClusterIP，现在我们通过在线修改的方式去改变他

[root@master ~]# kubectl edit svc/web01
我们只需要改动这几处地方，其他的地方不用变
ports:
# 这里加上一个nodePort，也就是你开放的端口，不写这里的话他就是随机开放一个端口
  - nodePort: 30888
    port: 80
    protocol: TCP
    targetPort: 80
#type这个地方将clusterIP改为NodePort
sessionAffinity: None
type: NodePort
# 改完这些之后保存退出就可以了
[root@master ~]# kubectl get svc
NAME         TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)        AGE
kubernetes   ClusterIP   10.96.0.1      <none>        443/TCP        38d
web01        NodePort    10.104.17.66   <none>        80:30888/TCP   114s

可见，他的类型从ClusterIP变成了NodePort
这个时候你可能会问，他后面还是得跟上端口啊，而且端口还是5位数，不太好记，也是一样的很麻烦啊，其实我们的服务并不会直接通过这种方式去暴露在互联网上，我们会通过负载均衡器或者防火墙来开放80/443端口，然后流量到80/443之后负载均衡器会把流量转发到对应的端口，这样的话用户就不用知道具体的端口，他只用输入域名或者IP就可以访问到我们的服务了

2.LoadBalance

要使用这个方式需要先安装第三方插件，因为LoadBalance翻译过来是负载均衡器，但是实际上不是的，他是一个地址池
集群起来之后每个节点都分配一个公网IP会有点浪费资源
我们通过实验来理解

前置条件：需要安装一个三方插件

kubectl apply -f https://raw.githubusercontent.com/metallb/metallb/v0.14.3/config/manifests/metallb-native.yaml

如果因为网络原因创建失败的话可以使用一些特殊手段来尝试一下

安装完成之后执行这个命令

[root@master metallb]# kubectl get pods -n metallb-system 
NAME                         READY   STATUS    RESTARTS   AGE
controller-7d678cf54-w8r9x   1/1     Running   0          62s
speaker-2crsx                1/1     Running   0          61s
speaker-s668p                1/1     Running   0          61s
speaker-wcb7s                1/1     Running   0          61s

会有一个新的命名空间
注意
：我们是模拟公网IP地址池，你把地址池里的地址当作是公网的IP地址就行了
安装完成之后再创建2个yaml文件，一个是创建地址池，一个是配置2层工作模式

# 创建地址池
apiVersion: metallb.io/v1beta1
kind: IPAddressPool
metadata:
  name: first
  namespace: metallb-system
spec:
  addresses:
# 写上地址段
  - 192.168.200.240-192.168.200.250

这就是第一个yaml文件
然后再来第二个yaml文件

apiVersion: metallb.io/v1beta1
kind: L2Advertisement
metadata:
  name: example
  namespace: metallb-system
spec:
  ipAddressPools:
  - first

然后应用这2个yaml文件

[root@master ~]# kubectl apply -f ippools.yaml 
[root@master ~]# kubectl apply -f l2.yaml 
# 查询一下地址池
[root@master ~]# kubectl get ipaddresspools.metallb.io -n metallb-system 
NAME    AUTO ASSIGN   AVOID BUGGY IPS   ADDRESSES
first   true          false             ["192.168.200.240-192.168.200.250"]

然后我们现在创建一个nginx的pod，使用Load Balance方式将他发布出去

[root@master ~]# kubectl run nginx01 --image nginx --image-pull-policy IfNotPresent 
pod/nginx01 created
[root@master ~]# kubectl expose pods/nginx01 --type LoadBalancer --port 80 --target-port 80
service/nginx01 exposed
[root@master ~]# kubectl get pods
NAME      READY   STATUS    RESTARTS   AGE
nginx01   1/1     Running   0          21s
[root@master ~]# kubectl get svc
NAME         TYPE           CLUSTER-IP     EXTERNAL-IP       PORT(S)        AGE
kubernetes   ClusterIP      10.96.0.1      <none>            443/TCP        38d
nginx01      LoadBalancer   10.99.228.13   192.168.200.240   80:32042/TCP   8s

到这里我们可以看到，external-ip这里是有一个ip地址的，我们来尝试访问一下这个IP地址

没有问题，我们同时也看到在port那里有一个32042的端口，这个端口是干嘛的呢？这个端口其实就是nodePort的端口
我们使用某个节点的IP:32042

没有任何的问题
我们之前就说了这个是模拟的公网IP，如果你是在公有云上部署这个并且你有一些公网IP，那么就可以直接通过公网IP来发布你的服务了

3.Ingress(推荐/重点)

ingress会根据用户的不同需求将流量转发到对应的服务上
使用ingress的话有3个步骤

1. 配置反向代理
2. 创建pod
3. 创建svc
   操作开始
   我们现在开始配置反向代理，配置反向代理不要用nginx去手动配置，虽然行得通，但是很麻烦，我们直接使用ingress-nginx这个镜像

kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.8.2/deploy/static/provider/cloud/deploy.yaml

如果网络不好的话这样操作

# 在node1和node2上操作
[root@node1 ~]# crictl pull registry.cn-hangzhou.aliyuncs.com/cloudcs/kube-webhook-certgen:v20220916-gd32f8c343
[root@node1 ~]# crictl pull registry.cn-hangzhou.aliyuncs.com/cloudcs/controller:v1.6.4

然后将文件内容复制下来写到一个yaml文件里，需要改3个地方

[root@master ingress]# grep image deploy.yaml  
# 这3个镜像的地方需要改，第2个和第3个使用的是同一个镜像
        image: registry.cn-hangzhou.aliyuncs.com/cloudcs/controller:v1.6.4
        imagePullPolicy: IfNotPresent
        image: registry.cn-hangzhou.aliyuncs.com/cloudcs/kube-webhook-certgen:v20220916-gd32f8c343
        imagePullPolicy: IfNotPresent
        image: registry.cn-hangzhou.aliyuncs.com/cloudcs/kube-webhook-certgen:v20220916-gd32f8c343
        imagePullPolicy: IfNotPresent

然后apply

[root@master ingress]# kubectl get pods -n ingress-nginx 
NAME                                        READY   STATUS      RESTARTS   AGE
ingress-nginx-admission-create-z27v4        0/1     Completed   0          5m44s
ingress-nginx-admission-patch-fnx6b         0/1     Completed   0          5m44s
ingress-nginx-controller-7ffff4c7dd-jps9m   1/1     Running     0          5m44s

他最后应该变成这样，2个完成，1个运行中
再查看一下svc

[root@master ~]# kubectl get svc -n ingress-nginx 
NAME                                 TYPE           CLUSTER-IP       EXTERNAL-IP       PORT(S)                      AGE
ingress-nginx-controller             LoadBalancer   10.106.120.188   192.168.200.241   80:32558/TCP,443:32206/TCP   11h
ingress-nginx-controller-admission   ClusterIP      10.96.125.66     <none>            443/TCP                      11h

这些东西都是为了反向代理做支撑的
然后我们还需要定义一个规则

# 这个规则就是用户访问www.web1.com 的时候流量会走到pod01上，访问www.web2.com流量会到pod02上，www.web3.com则会到pod03
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: ingress-wildcard-host
spec:
  rules:
  - host: "www.web1.com"
    http:
      paths:
      - pathType: Prefix
        path: "/"
        backend:
          service:
            name: pod01
            port:
              number: 80
  - host: "www.web2.com"
    http:
      paths:
      - pathType: Prefix
        path: "/"
        backend:
          service:
            name: pod02
            port:
              number: 80
  - host: "www.web3.com"
    http:
      paths:
      - pathType: Prefix
        path: "/"
        backend:
          service:
            name: pod03
            port:
              number: 80

这个文件先别急着apply，还有一个操作

# 修改ingress的默认class
[root@master ~]# kubectl edit ingressclasses.networking.k8s.io
apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
  annotations:
# 加上这一行，让他有一个默认类
    ingressclass.kubernetes.io/is-default-class: "true"
    kubectl.kubernetes.io/last-applied-configuration: |

然后我们开始创建pod

# 创建3个pod，在ingress-nginx命名空间下，在哪都无所谓，我这里是在这个命名空间下的，只需要保证你的pod,svc和ingress在同一命名空间就行
[root@master ~]# kubectl run pod01 --image nginx --image-pull-policy IfNotPresent --namespace ingress-nginx
pod/pod01 created
[root@master ~]# kubectl run pod02 --image nginx --image-pull-policy IfNotPresent --namespace ingress-nginx
pod/pod02 created
[root@master ~]# kubectl run pod03 --image nginx --image-pull-policy IfNotPresent --namespace ingress-nginx
pod/pod03 created
[root@master ~]# kubectl get pods -n ingress-nginx
NAME    READY   STATUS    RESTARTS   AGE
pod01   1/1     Running   0          21s
pod02   1/1     Running   0          15s
pod03   1/1     Running   0          11s

# 然后进去pod修改index文件
[root@master ~]# kubectl exec -it pods/pod01 -- bash
root@pod01:/# echo 666666 > /usr/share/nginx/html/index.html
[root@master ~]# kubectl exec -it pods/pod02 -- bash
root@pod01:/# echo 222 > /usr/share/nginx/html/index.html
[root@master ~]# kubectl exec -it pods/pod03 -- bash
root@pod01:/# echo 333 > /usr/share/nginx/html/index.html

然后我们去创建svc

[root@master ~]# kubectl expose pods/pod01  --port 80 --target-port 80
service/pod01 exposed
[root@master ~]# kubectl expose pods/pod02  --port 80 --target-port 80
service/pod02 exposed
[root@master ~]# kubectl expose pods/pod03  --port 80 --target-port 80
service/pod03 exposed

当在ingress-nginx命名空间下创建完pod和svc之后我们再去apply那个规则文件

[root@master ~]# kubectl apply -f ingress.yaml
# 然后我们来查看一下
[root@master ingress]# kubectl describe ingress
……省略一些信息
Rules:
  Host          Path  Backends
  ----          ----  --------
  www.web1.com  
                /   pod01:80 (10.244.104.40:80)
  www.web2.com  
                /   pod02:80 (10.244.104.19:80)
  www.web3.com  
                /   pod03:80 (10.244.166.145:80)
Annotations:    <none>
Events:
  Type    Reason  Age                From                      Message
  ----    ------  ----               ----                      -------
  Normal  Sync    26m (x2 over 27m)  nginx-ingress-controller  Scheduled for sync

这里我么可以看到 www.web1.com 他会转发到pod01上，那么没有问题

下面是验证环节，为了方便，我们直接在master节点上修改hosts文件

# 先查询一下ingress的ip
[root@master ingress]# kubectl get ingress
NAME                    CLASS   HOSTS                                    ADDRESS           PORTS   AGE
ingress-wildcard-host   nginx   www.web1.com,www.web2.com,www.web3.com   192.168.200.241   80      5m28s
# 这里他的IP是192.168.200.241
[root@master ~]# vim /etc/hosts
192.168.200.200 master 
192.168.200.210 node1 
192.168.200.220 node2 
192.168.200.241 www.web1.com
192.168.200.241 www.web2.com
192.168.200.241 www.web3.com

好，我们来访问一下

[root@master ingress]#  curl www.web1.com
666666
[root@master ingress]#  curl www.web2.com
222
[root@master ingress]#  curl www.web3.com
333

好的，我们的规则生效了，这个就是ingress发布，操作有点麻烦，但是可以对应不同的需求

这些就是服务的发布了，没有讲到ClusterIP，因为这个只能集群内部访问，上一节有提到过这个

前言

大家好，这里是白泽。
《Go语言的100个错误以及如何避免》
是最近朋友推荐我阅读的书籍，我初步浏览之后，大为惊喜。就像这书中第一章的标题说到的：“
Go: Simple to learn but hard to master
”，整本书通过分析100个错误使用 Go 语言的场景，带你深入理解 Go 语言。

我的愿景是以这套文章，在保持权威性的基础上，脱离对原文的依赖，对这100个场景进行篇幅合适的中文讲解。所涉内容较多，总计约 8w 字，这是该系列的第五篇文章，对应书中第40-47个错误场景。