-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathsearch.xml
120 lines (57 loc) · 105 KB
/
search.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
<?xml version="1.0" encoding="utf-8"?>
<search>
<entry>
<title>hexo博客中插入图片失败-个人思路</title>
<link href="/post/996b6ca0.html"/>
<url>/post/996b6ca0.html</url>
<content type="html"><![CDATA[<h3 id="解决方案"><a href="#解决方案" class="headerlink" title="解决方案"></a>解决方案</h3><h4 id="1、创建图片资源文件夹"><a href="#1、创建图片资源文件夹" class="headerlink" title="1、创建图片资源文件夹"></a>1、创建图片资源文件夹</h4><p>网上有关的解决方式几乎很大一部分会提到这一点：将_config.yml 文件中的post_asset_folder 选项设为 true 来打开。事实上这正是hexo官方文档给出的解决方案之一中的一个步骤。仔细阅读后会发现如下几点：</p><pre><code>该操作的作用就是在使用hexo new xxx指令新建博文时，在相同路径下同步创建一个xxx文件夹，而xxx文件夹的作用就是用来存放图片资源；就我个人而言，我偏好于直接在source\_posts文件夹下新建md文件，而不是通过hexo new xxx指令；那么直接新建xxx.md再新建xxx文件夹，这种操作的最终效果和使用hexo new xxx指令新建博文的效果一样吗？经过实测，是一样的。</code></pre><p>基于以上3点，告诉大家几个结论：</p><pre><code>1.新建博文可以不用hexo new xxx指令，我较为推荐直接新建文件和文件夹的方式，只要达到一个md文件，一个同名文件夹的效果即可；2.【将_config.yml 文件中的post_asset_folder 选项设为 true 】是必须的！理论上既然没用hexo new xxx指令，文件夹也是我自己新建的，这一步设置的意义似乎并不存在，但是后文介绍的插件必须在post_asset_folder 选项设为 true的情况下才能生效——本人亲测，大家记住这么设置即可！注意:是在_config.yml里面</code></pre><p><img src="/post/996b6ca0/image-20230218135236445.png" alt="image-20230218135236445"></p><h4 id="2、typora中图像设置"><a href="#2、typora中图像设置" class="headerlink" title="2、typora中图像设置"></a>2、typora中图像设置</h4><p>按如下设置</p><p><img src="/post/996b6ca0/image-20230218134527900.png" alt="image-20230218134527900"></p><p>框里的路径是：./${filename}。./表示当前文件夹，${filename}表示当前文件名。这么设置的好处：</p><pre><code>图片资源文件夹有了；而且是同名文件夹！</code></pre><p>这么设置的结果就是：想写篇博客，在source_posts文件夹下新建xxx.md文件，写着写着需要插一张图，从别处复制，然后在typora中直接粘贴，bling!图片资源文件夹自动搞定，并不用关心什么文件夹，只管专注于md文件即可。</p><h4 id="3、插件下载"><a href="#3、插件下载" class="headerlink" title="3、插件下载"></a>3、插件下载</h4><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">npm install https://github.com/CodeFalling/hexo-asset-image --save</span><br></pre></td></tr></table></figure><h4 id="4、如下情况即为成功"><a href="#4、如下情况即为成功" class="headerlink" title="4、如下情况即为成功"></a>4、如下情况即为成功</h4><p>最后三连:hexo clean&&hexo g&&hexo deploy</p><p>用Sublime Text打开./post/index.html，img出现如下情况即为成功。</p><p><img src="/post/996b6ca0/image-20230218135545495.png" alt="image-20230218135545495"></p>]]></content>
<categories>
<category> hexo </category>
</categories>
<tags>
<tag> hexo </tag>
</tags>
</entry>
<entry>
<title>Rabbitmq面试题</title>
<link href="/post/df0b9b6c.html"/>
<url>/post/df0b9b6c.html</url>
<content type="html"><![CDATA[<h4 id="RabbitMQ-是什么？"><a href="#RabbitMQ-是什么？" class="headerlink" title="RabbitMQ 是什么？"></a>RabbitMQ 是什么？</h4><p>RabbitMQ 是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件）。RabbitMQ 服务器是用 Erlang 语言编写的，而群集和故障转移是构建在开放电信平台框架上的。所有主要的编程语言均有与代理接口通讯的客户端库。</p><p>PS: 也可能直接问什么是消息队列？消息队列就是一个使用队列来通信的组件。</p><h4 id="RabbitMQ-特点？"><a href="#RabbitMQ-特点？" class="headerlink" title="RabbitMQ 特点？"></a>RabbitMQ 特点？</h4><pre><code>可靠性: RabbitMQ 使用一些机制来保证可靠性， 如持久化、传输确认及发布确认等。灵活的路由 : 在消息进入队列之前，通过交换器来路由消息。对于典型的路由功能， RabbitMQ 己经提供了一些内置的交换器来实现。针对更复杂的路由功能，可以将多个 交换器绑定在一起， 也可以通过插件机制来实现自己的交换器。扩展性: 多个 RabbitMQ 节点可以组成一个集群，也可以根据实际业务情况动态地扩展 集群中节点。高可用性 : 队列可以在集群中的机器上设置镜像，使得在部分节点出现问题的情况下队 列仍然可用。多种协议: RabbitMQ 除了原生支持 AMQP 协议，还支持 STOMP， MQTT 等多种消息 中间件协议。多语言客户端 :RabbitMQ 几乎支持所有常用语言，比如 Java、 Python、 Ruby、 PHP、 C#、 JavaScript 等。管理界面 : RabbitMQ 提供了一个易用的用户界面，使得用户可以监控和管理消息、集 群中的节点等。插件机制 : RabbitMQ 提供了许多插件 ， 以实现从多方面进行扩展，当然也可以编写自 己的插件。</code></pre><h4 id="AMQP-是什么？"><a href="#AMQP-是什么？" class="headerlink" title="AMQP 是什么？"></a>AMQP 是什么？</h4><p>RabbitMQ 就是 AMQP 协议的 Erlang 的实现 (当然 RabbitMQ 还支持 STOMP2、 MQTT3 等协议 ) AMQP 的模型架构 和 RabbitMQ 的模型架构是一样的，生产者将消息发送给交换器，交换器和队列绑定 。</p><p>RabbitMQ 中的交换器、交换器类型、队列、绑定、路由键等都是遵循的 AMQP 协议中相 应的概念。目前 RabbitMQ 最新版本默认支持的是 AMQP 0-9-1。</p><h4 id="AMQP-协议-3-层？"><a href="#AMQP-协议-3-层？" class="headerlink" title="AMQP 协议 3 层？"></a>AMQP 协议 3 层？</h4><pre><code>Module Layer: 协议最高层，主要定义了一些客户端调用的命令，客户端可以用这些命令实现自己的业务逻辑。Session Layer: 中间层，主要负责客户端命令发送给服务器，再将服务端应答返回客户端，提供可靠性同步机制和错误处理。TransportLayer: 最底层，主要传输二进制数据流，提供帧的处理、信道服用、错误检测和数据表示等。</code></pre><h4 id="AMQP-模型的几大组件？"><a href="#AMQP-模型的几大组件？" class="headerlink" title="AMQP 模型的几大组件？"></a>AMQP 模型的几大组件？</h4><pre><code>交换器 (Exchange)：消息代理服务器中用于把消息路由到队列的组件。队列 (Queue)：用来存储消息的数据结构，位于硬盘或内存中。绑定 (Binding)：一套规则，告知交换器消息应该将消息投递给哪个队列。</code></pre><h4 id="说说生产者-Producer-和消费者-Consumer"><a href="#说说生产者-Producer-和消费者-Consumer" class="headerlink" title="说说生产者 Producer 和消费者 Consumer?"></a>说说生产者 Producer 和消费者 Consumer?</h4><p>生产者</p><pre><code>消息生产者，就是投递消息的一方。消息一般包含两个部分：消息体（payload) 和标签 (Label)。</code></pre><p>消费者</p><pre><code>消费消息，也就是接收消息的一方。消费者连接到 RabbitMQ 服务器，并订阅到队列上。消费消息时只消费消息体，丢弃标签。</code></pre><h4 id="为什么需要消息队列？"><a href="#为什么需要消息队列？" class="headerlink" title="为什么需要消息队列？"></a>为什么需要消息队列？</h4><p>从本质上来说是因为互联网的快速发展，业务不断扩张，促使技术架构需要不断的演进。</p><p>从以前的单体架构到现在的微服务架构，成百上千的服务之间相互调用和依赖。从互联网初期一个服务器上有 100 个在线用户已经很了不得，到现在坐拥 10 亿日活的微信。此时，我们需要有一个「工具」来解耦服务之间的关系、控制资源合理合时的使用以及缓冲流量洪峰等等。因此，消息队列就应运而生了。</p><p>它常用来实现：异步处理、服务解耦、流量控制（削峰）。</p><h4 id="说说-Broker-服务节点、Queue-队列、Exchange-交换器？"><a href="#说说-Broker-服务节点、Queue-队列、Exchange-交换器？" class="headerlink" title="说说 Broker 服务节点、Queue 队列、Exchange 交换器？"></a>说说 Broker 服务节点、Queue 队列、Exchange 交换器？</h4><pre><code>Broker 可以看做 RabbitMQ 的服务节点。一般请下一个 Broker 可以看做一个 RabbitMQ 服务器。Queue:RabbitMQ 的内部对象，用于存储消息。多个消费者可以订阅同一队列，这时队列中的消息会被平摊（轮询）给多个消费者进行处理。Exchange: 生产者将消息发送到交换器，由交换器将消息路由到一个或者多个队列中。当路由不到时，或返回给生产者或直接丢弃。</code></pre><h4 id="消息队列有什么优缺点"><a href="#消息队列有什么优缺点" class="headerlink" title="消息队列有什么优缺点"></a>消息队列有什么优缺点</h4><p>优点上面已经说了，就是在特殊场景下有其对应的好处，解耦、异步、削峰。缺点有以下几个：</p><pre><code>系统可用性降低 系统引入的外部依赖越多，越容易挂掉。万一 MQ 挂了，MQ 一挂，整套系统崩 溃，你不就完了？系统复杂度提高 硬生生加个 MQ 进来，你怎么保证消息没有重复消费？怎么处理消息丢失的情况？怎么保证消息传递的顺序性？问题一大堆。一致性问题 A 系统处理完了直接返回成功了，人都以为你这个请求就成功了；但是问题是，要是 BCD 三个系统那里，BD 两个系统写库成功了，结果 C 系统写库失败了，咋整？你这数据就不一致 了。</code></pre><h4 id="如何保证消息的可靠性？"><a href="#如何保证消息的可靠性？" class="headerlink" title="如何保证消息的可靠性？"></a>如何保证消息的可靠性？</h4><p>消息到 MQ 的过程中搞丢，MQ 自己搞丢，MQ 到消费过程中搞丢。</p><p>生产者到RabbitMQ：事务机制和 Confirm 机制，注意：事务机制和 Confirm 机制是互斥的，两者不能共存，会导致 RabbitMQ 报错。</p><p>RabbitMQ自身：持久化、集群、普通模式、镜像模式。</p><p>RabbitMQ到消费者：basicAck 机制、死信队列、消息补偿机制。</p><h4 id="什么是-RoutingKey-路由键？"><a href="#什么是-RoutingKey-路由键？" class="headerlink" title="什么是 RoutingKey 路由键？"></a>什么是 RoutingKey 路由键？</h4><p>生产者将消息发送给交换器的时候，会指定一个 RoutingKey, 用来指定这个消息的路由规则，这个 RoutingKey 需要与交换器类型和绑定键 (BindingKey) 联合使用才能最终生效。</p><h4 id="Binding-绑定？"><a href="#Binding-绑定？" class="headerlink" title="Binding 绑定？"></a>Binding 绑定？</h4><p>通过绑定将交换器和队列关联起来，一般会指定一个 BindingKey, 这样 RabbitMq 就知道如何正确路由消息到队列了。</p><h4 id="交换器-4-种类型？"><a href="#交换器-4-种类型？" class="headerlink" title="交换器 4 种类型？"></a>交换器 4 种类型？</h4><p>主要有以下 4 种。</p><pre><code>fanout: 把所有发送到该交换器的消息路由到所有与该交换器绑定的队列中。direct: 把消息路由到 BindingKey 和 RoutingKey 完全匹配的队列中。topic:匹配规则：</code></pre><p>RoutingKey<code>为一个 点号'.': 分隔的字符串。比如:</code>java.xiaoka.show</p><p>BindingKey 和 RoutingKey 一样也是点号 “.“分隔的字符串。</p><p>BindingKey 可使用 * 和 # 用于做模糊匹配，* 匹配一个单词，# 匹配多个或者 0 个</p><p>headers: 不依赖路由键匹配规则路由消息。是根据发送消息内容中的 headers 属性进行匹配。性能差，基本用不到。</p><h4 id="生产者消息运转？"><a href="#生产者消息运转？" class="headerlink" title="生产者消息运转？"></a>生产者消息运转？</h4><pre><code>Producer 先连接到 Broker, 建立连接 Connection, 开启一个信道 (Channel)。Producer 声明一个交换器并设置好相关属性。Producer 声明一个队列并设置好相关属性。Producer 通过路由键将交换器和队列绑定起来。Producer 发送消息到 Broker, 其中包含路由键、交换器等信息。相应的交换器根据接收到的路由键查找匹配的队列。如果找到，将消息存入对应的队列，如果没有找到，会根据生产者的配置丢弃或者退回给生产者。关闭信道。管理连接。</code></pre><h4 id="消费者接收消息过程？"><a href="#消费者接收消息过程？" class="headerlink" title="消费者接收消息过程？"></a>消费者接收消息过程？</h4><pre><code>Producer 先连接到 Broker, 建立连接 Connection, 开启一个信道 (Channel)。向 Broker 请求消费响应的队列中消息，可能会设置响应的回调函数。等待 Broker 回应并投递相应队列中的消息，接收消息。消费者确认收到的消息，ack。RabbitMq 从队列中删除已经确定的消息。关闭信道。关闭连接。</code></pre><h5 id="交换器无法根据自身类型和路由键找到符合条件队列时，有哪些处理？"><a href="#交换器无法根据自身类型和路由键找到符合条件队列时，有哪些处理？" class="headerlink" title="交换器无法根据自身类型和路由键找到符合条件队列时，有哪些处理？"></a>交换器无法根据自身类型和路由键找到符合条件队列时，有哪些处理？</h5><pre><code>mandatory ：true 返回消息给生产者。mandatory: false 直接丢弃。</code></pre><h4 id="死信队列？"><a href="#死信队列？" class="headerlink" title="死信队列？"></a>死信队列？</h4><p>DLX，全称为 Dead-Letter-Exchange，死信交换器，死信邮箱。当消息在一个队列中变成死信 (dead message) 之后，它能被重新被发送到另一个交换器中，这个交换器就是 DLX，绑定 DLX 的队列就称之为死信队列。</p><h4 id="导致的死信的几种原因？"><a href="#导致的死信的几种原因？" class="headerlink" title="导致的死信的几种原因？"></a>导致的死信的几种原因？</h4><pre><code>消息被拒（Basic.Reject /Basic.Nack) 且 requeue = false。消息 TTL 过期。队列满了，无法再添加。</code></pre><h4 id="延迟队列？"><a href="#延迟队列？" class="headerlink" title="延迟队列？"></a>延迟队列？</h4><p>存储对应的延迟消息，指当消息被发送以后，并不想让消费者立刻拿到消息，而是等待特定时间后，消费者才能拿到这个消息进行消费。</p><h4 id="优先级队列？"><a href="#优先级队列？" class="headerlink" title="优先级队列？"></a>优先级队列？</h4><pre><code>优先级高的队列会先被消费。可以通过 x-max-priority 参数来实现。当消费速度大于生产速度且 Broker 没有堆积的情况下，优先级显得没有意义。</code></pre><h4 id="事务机制？"><a href="#事务机制？" class="headerlink" title="事务机制？"></a>事务机制？</h4><p>RabbitMQ 客户端中与事务机制相关的方法有三个:</p><pre><code>channel.txSelect 用于将当前的信道设置成事务模式。channel . txCommit 用于提交事务 。channel . txRollback 用于事务回滚，如果在事务提交执行之前由于 RabbitMQ 异常崩溃或者其他原因抛出异常，通过 txRollback 来回滚。</code></pre><h4 id="发送确认机制？"><a href="#发送确认机制？" class="headerlink" title="发送确认机制？"></a>发送确认机制？</h4><p>生产者把信道设置为 confirm 确认模式，设置后，所有再改信道发布的消息都会被指定一个唯一的 ID，一旦消息被投递到所有匹配的队列之后，RabbitMQ 就会发送一个确认（Basic.Ack) 给生产者（包含消息的唯一 ID)，这样生产者就知道消息到达对应的目的地了。</p><h4 id="消费者获取消息的方式？"><a href="#消费者获取消息的方式？" class="headerlink" title="消费者获取消息的方式？"></a>消费者获取消息的方式？</h4><pre><code>推拉</code></pre><h4 id="消费者某些原因无法处理当前接受的消息如何来拒绝？"><a href="#消费者某些原因无法处理当前接受的消息如何来拒绝？" class="headerlink" title="消费者某些原因无法处理当前接受的消息如何来拒绝？"></a>消费者某些原因无法处理当前接受的消息如何来拒绝？</h4><p>channel .basicNack channel .basicReject</p><h4 id="消息传输保证层级？"><a href="#消息传输保证层级？" class="headerlink" title="消息传输保证层级？"></a>消息传输保证层级？</h4><pre><code>At most once: 最多一次。消息可能会丢失，但不会重复传输。At least once：最少一次。消息绝不会丢失，但可能会重复传输。Exactly once: 恰好一次，每条消息肯定仅传输一次。</code></pre><h4 id="了解-Virtual-Host-吗？"><a href="#了解-Virtual-Host-吗？" class="headerlink" title="了解 Virtual Host 吗？"></a>了解 Virtual Host 吗？</h4><p>每一个 RabbitMQ 服务器都能创建虚拟的消息服务器，也叫虚拟主机 (virtual host)，简称 vhost。默认为 “/”。</p><h4 id="集群中的节点类型？"><a href="#集群中的节点类型？" class="headerlink" title="集群中的节点类型？"></a>集群中的节点类型？</h4><pre><code>内存节点：ram, 将变更写入内存。磁盘节点：disc, 磁盘写入操作。RabbitMQ 要求最少有一个磁盘节点。</code></pre><h4 id="队列结构？"><a href="#队列结构？" class="headerlink" title="队列结构？"></a>队列结构？</h4><p>通常由以下两部分组成</p><pre><code>rabbit_amqqueue_process: 负责协议相关的消息处理，即接收生产者发布的消息、向消费者交付消息、处理消息的确认 (包括生产端的 confirm 和消费端的 ack) 等。backing_queue: 是消息存储的具体形式和引擎，并向 rabbit amqqueue process 提供相关的接口以供调用。</code></pre><h4 id="RabbitMQ-中消息可能有的几种状态？"><a href="#RabbitMQ-中消息可能有的几种状态？" class="headerlink" title="RabbitMQ 中消息可能有的几种状态？"></a>RabbitMQ 中消息可能有的几种状态？</h4><pre><code>alpha: 消息内容 (包括消息体、属性和 headers) 和消息索引都存储在内存中 。beta: 消息内容保存在磁盘中，消息索引保存在内存中。gamma: 消息内容保存在磁盘中，消息索引在磁盘和内存中都有 。delta: 消息内容和索引都在磁盘中 。</code></pre><h4 id="在何种场景下使用了消息中间件？"><a href="#在何种场景下使用了消息中间件？" class="headerlink" title="在何种场景下使用了消息中间件？"></a>在何种场景下使用了消息中间件？</h4><pre><code>接口之间耦合比较严重面对大流量并发时，容易被冲垮存在性能问题</code></pre><h4 id="生产者如何将消息可靠投递到-MQ？"><a href="#生产者如何将消息可靠投递到-MQ？" class="headerlink" title="生产者如何将消息可靠投递到 MQ？"></a>生产者如何将消息可靠投递到 MQ？</h4><pre><code>Client 发送消息给 MQ；MQ 将消息持久化后，发送 Ack 消息给 Client，此处有可能因为网络问题导致 Ack 消息无法发送到 Client，那么 Client 在等待超时后，会重传消息；Client 收到 Ack 消息后，认为消息已经投递成功。</code></pre><h4 id="MQ-如何将消息可靠投递到消费者？"><a href="#MQ-如何将消息可靠投递到消费者？" class="headerlink" title="MQ 如何将消息可靠投递到消费者？"></a>MQ 如何将消息可靠投递到消费者？</h4><pre><code>MQ 将消息 push 给 Client（或 Client 来 pull 消息）Client 得到消息并做完业务逻辑Client 发送 Ack 消息给 MQ，通知 MQ 删除该消息，此处有可能因为网络问题导致 Ack 失败，那么 Client 会重复消息，这里就引出消费幂等的问题；MQ 将已消费的消息删除</code></pre><h4 id="如何保证-RabbitMQ-消息队列的高可用？"><a href="#如何保证-RabbitMQ-消息队列的高可用？" class="headerlink" title="如何保证 RabbitMQ 消息队列的高可用？"></a>如何保证 RabbitMQ 消息队列的高可用？</h4><p>RabbitMQ 有三种模式：单机模式，普通集群模式，镜像集群模式。</p><pre><code>单机模式：就是 demo 级别的，一般就是你本地启动了玩玩儿的，没人生产用单机模式。普通集群模式：意思就是在多台机器上启动多个 RabbitMQ 实例，每个机器启动一个。镜像集群模式：这种模式，才是所谓的 RabbitMQ 的高可用模式，跟普通集群模式不一样的是，你创建的 queue，无论元数据 (元数据指 RabbitMQ 的配置数据) 还是 queue 里的消息都会存在于多个实例上，然后每次你写消息到 queue 的时候，都会自动把消息到多个实例的 queue 里进行消息同步。</code></pre>]]></content>
<categories>
<category> 消息队列 </category>
</categories>
<tags>
<tag> Rabbitmq </tag>
</tags>
</entry>
<entry>
<title>Shell编程入门</title>
<link href="/post/fa882019.html"/>
<url>/post/fa882019.html</url>
<content type="html"><![CDATA[<h3 id="一、Shell概述"><a href="#一、Shell概述" class="headerlink" title="一、Shell概述"></a>一、Shell概述</h3><p>Shell是一个命令行解释器，它接受应用程序/用户命令，然后调用操作系统内核。</p><p><img src="/post/fa882019/image-20230217211511748.png" alt="image-20230217211511748"></p><p>Shell还是一个功能相当强大的编程语言，易编写、易调试、灵活性强。</p><h5 id="查看Linux提供的Shell解释器"><a href="#查看Linux提供的Shell解释器" class="headerlink" title="查看Linux提供的Shell解释器"></a>查看Linux提供的Shell解释器</h5><figure class="highlight sh"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line"><span class="built_in">cat</span> /etc/shells</span><br></pre></td></tr></table></figure><h5 id="bash和sh的关系"><a href="#bash和sh的关系" class="headerlink" title="bash和sh的关系"></a>bash和sh的关系</h5><figure class="highlight sh"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">ll | grep bash</span><br></pre></td></tr></table></figure><p><img src="/post/fa882019/image-20230217212110363.png" alt="image-20230217212110363"></p><h5 id="查看Centos默认的解析器是bash"><a href="#查看Centos默认的解析器是bash" class="headerlink" title="查看Centos默认的解析器是bash"></a>查看Centos默认的解析器是bash</h5><figure class="highlight sh"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line"><span class="built_in">echo</span> <span class="variable">$SHELL</span></span><br></pre></td></tr></table></figure><p><img src="/post/fa882019/image-20230217212228290.png" alt="image-20230217212228290"></p>]]></content>
<categories>
<category> Linux </category>
</categories>
<tags>
<tag> Linux Shell </tag>
</tags>
</entry>
<entry>
<title>K8s面试题</title>
<link href="/post/19ce6070.html"/>
<url>/post/19ce6070.html</url>
<content type="html"><![CDATA[<h4 id="docker的工作原理是什么，讲一下"><a href="#docker的工作原理是什么，讲一下" class="headerlink" title="docker的工作原理是什么，讲一下"></a>docker的工作原理是什么，讲一下</h4><p>docker是一个Client-Server结构的系统，docker守护进程运行在宿主机上，守护进程从客户端接受命令并管理运行在主机上的容器，容器是一个运行时环境，这就是我们说的集装箱。</p><h4 id="docker的组成包含哪几大部分"><a href="#docker的组成包含哪几大部分" class="headerlink" title="docker的组成包含哪几大部分"></a>docker的组成包含哪几大部分</h4><p>一个完整的docker有以下几个部分组成：<br>1、docker client，客户端，为用户提供一系列可执行命令，用户用这些命令实现跟 docker daemon 交互；<br>2、docker daemon，守护进程，一般在宿主主机后台运行，等待接收来自客户端的请求消息；<br>3、docker image，镜像，镜像run之后就生成为docker容器；<br>4、docker container，容器，一个系统级别的服务，拥有自己的ip和系统目录结构；运行容器前需要本地存在对应的镜像，如果本地不存在该镜像则就去镜像仓库下载。</p><p>docker 使用客户端-服务器 (C/S) 架构模式，使用远程api来管理和创建docker容器。docker 容器通过 docker 镜像来创建。容器与镜像的关系类似于面向对象编程中的对象与类。</p><h4 id="docker与传统虚拟机的区别什么？"><a href="#docker与传统虚拟机的区别什么？" class="headerlink" title="docker与传统虚拟机的区别什么？"></a>docker与传统虚拟机的区别什么？</h4><p>1、传统虚拟机是需要安装整个操作系统的，然后再在上面安装业务应用，启动应用，通常需要几分钟去启动应用，而docker是直接使用镜像来运行业务容器的，其容器启动属于秒级别；<br>2、Docker需要的资源更少，Docker在操作系统级别进行虚拟化，Docker容器和内核交互，几乎没有性能损耗，而虚拟机运行着整个操作系统，占用物理机的资源就比较多;<br>3、Docker更轻量，Docker的架构可以共用一个内核与共享应用程序库，所占内存极小;同样的硬件环境，Docker运行的镜像数远多于虚拟机数量，对系统的利用率非常高;<br>4、与虚拟机相比，Docker隔离性更弱，Docker属于进程之间的隔离，虚拟机可实现系统级别隔离;<br>5、Docker的安全性也更弱，Docker的租户root和宿主机root相同，一旦容器内的用户从普通用户权限提升为root权限，它就直接具备了宿主机的root权限，进而可进行无限制的操作。虚拟机租户root权限和宿主机的root虚拟机权限是分离的，并且虚拟机利用如Intel的VT-d和VT-x的ring-1硬件隔离技术，这种技术可以防止虚拟机突破和彼此交互，而容器至今还没有任何形式的硬件隔离;<br>6、Docker的集中化管理工具还不算成熟，各种虚拟化技术都有成熟的管理工具，比如：VMware vCenter提供完备的虚拟机管理能力;<br>7、Docker对业务的高可用支持是通过快速重新部署实现的，虚拟化具备负载均衡，高可用、容错、迁移和数据保护等经过生产实践检验的成熟保障机制，Vmware可承诺虚拟机99.999%高可用，保证业务连续性;<br>8、虚拟化创建是分钟级别的，Docker容器创建是秒级别的，Docker的快速迭代性，决定了无论是开发、测试、部署都可以节省大量时间;<br>9、虚拟机可以通过镜像实现环境交付的一致性，但镜像分发无法体系化，Docker在Dockerfile中记录了容器构建过程，可在集群中实现快速分发和快速部署。</p><h4 id="docker技术的三大核心概念是什么？"><a href="#docker技术的三大核心概念是什么？" class="headerlink" title="docker技术的三大核心概念是什么？"></a>docker技术的三大核心概念是什么？</h4><p>镜像：镜像是一种轻量级、可执行的独立软件包，它包含运行某个软件所需的所有内容，我们把应用程序和配置依赖打包好形成一个可交付的运行环境(包括代码、运行时需要的库、环境变量和配置文件等)，这个打包好的运行环境就是image镜像文件。<br>容器：容器是基于镜像创建的，是镜像运行起来之后的一个实例，容器才是真正运行业务程序的地方。如果把镜像比作程序里面的类，那么容器就是对象。<br>镜像仓库：存放镜像的地方，研发工程师打包好镜像之后需要把镜像上传到镜像仓库中去，然后就可以运行有仓库权限的人拉取镜像来运行容器了。</p><h4 id="centos镜像几个G，但是docker-centos镜像才几百兆，这是为什么？"><a href="#centos镜像几个G，但是docker-centos镜像才几百兆，这是为什么？" class="headerlink" title="centos镜像几个G，但是docker centos镜像才几百兆，这是为什么？"></a>centos镜像几个G，但是docker centos镜像才几百兆，这是为什么？</h4><p>一个完整的Linux操作系统包含Linux内核和rootfs根文件系统，即我们熟悉的/dev、/proc/、/bin等目录。我们平时看到的centOS除了rootfs，还会选装很多软件，服务，图形桌面等，所以centOS镜像有好几个G也不足为奇。<br>而对于容器镜像而言，所有容器都是共享宿主机的Linux 内核的，而对于docker镜像而言，docker镜像只需要提供一个很小的rootfs即可，只需要包含最基本的命令，工具，程序库即可，所有docker镜像才会这么小。</p><h4 id="讲一下镜像的分层结构以及为什么要使用镜像的分层结构？"><a href="#讲一下镜像的分层结构以及为什么要使用镜像的分层结构？" class="headerlink" title="讲一下镜像的分层结构以及为什么要使用镜像的分层结构？"></a>讲一下镜像的分层结构以及为什么要使用镜像的分层结构？</h4><p>一个新的镜像其实是从 base 镜像一层一层叠加生成的。每安装一个软件，dockerfile中使用RUN命令，就会在现有镜像的基础上增加一层，这样一层一层的叠加最后构成整个镜像。所以我们docker pull拉取一个镜像的时候会看到docker是一层层拉去的。</p><p>分层机构最大的一个好处就是 ： 共享资源。比如：有多个镜像都从相同的 base 镜像构建而来，那么 Docker Host 只需在磁盘上保存一份 base 镜像；同时内存中也只需加载一份 base 镜像，就可以为所有容器服务了。而且镜像的每一层都可以被共享。</p><h4 id="讲一下容器的copy-on-write特性，修改容器里面的内容会修改镜像吗？"><a href="#讲一下容器的copy-on-write特性，修改容器里面的内容会修改镜像吗？" class="headerlink" title="讲一下容器的copy-on-write特性，修改容器里面的内容会修改镜像吗？"></a>讲一下容器的copy-on-write特性，修改容器里面的内容会修改镜像吗？</h4><p>我们知道，镜像是分层的，镜像的每一层都可以被共享，同时，镜像是只读的。当一个容器启动时，一个新的可写层被加载到镜像的顶部，这一层通常被称作“容器层”，“容器层”之下的都叫“镜像层”。</p><p>所有对容器的改动 - 无论添加、删除、还是修改文件，都只会发生在容器层中，因为只有容器层是可写的，容器层下面的所有镜像层都是只读的。镜像层数量可能会很多，所有镜像层会联合在一起组成一个统一的文件系统。如果不同层中有一个相同路径的文件，比如 /a，上层的 /a 会覆盖下层的 /a，也就是说用户只能访问到上层中的文件 /a。在容器层中，用户看到的是一个叠加之后的文件系统。</p><p>添加文件时：在容器中创建文件时，新文件被添加到容器层中。<br>读取文件：在容器中读取某个文件时，Docker 会从上往下依次在各镜像层中查找此文件。一旦找到，立即将其复制到容器层，然后打开并读入内存。<br>修改文件：在容器中修改已存在的文件时，Docker 会从上往下依次在各镜像层中查找此文件。一旦找到，立即将其复制到容器层，然后修改之。<br>删除文件：在容器中删除文件时，Docker 也是从上往下依次在镜像层中查找此文件。找到后，会在容器层中记录下此删除操作。</p><p>只有当需要修改时才复制一份数据，这种特性被称作 Copy-on-Write。可见，容器层保存的是镜像变化的部分，不会对镜像本身进行任何修改。</p><h4 id="简单描述一下Dockerfile的整个构建镜像过程"><a href="#简单描述一下Dockerfile的整个构建镜像过程" class="headerlink" title="简单描述一下Dockerfile的整个构建镜像过程"></a>简单描述一下Dockerfile的整个构建镜像过程</h4><p>1、首先，创建一个目录用于存放应用程序以及构建过程中使用到的各个文件等；<br>2、然后，在这个目录下创建一个Dockerfile文件，一般建议Dockerfile的文件名就是Dockerfile；<br>3、编写Dockerfile文件，编写指令，如，使用FROM 指令指定基础镜像，COPY指令复制文件，RUN指令指定要运行的命令，ENV设置环境变量，EXPOSE指定容器要暴露的端口，WORKDIR设置当前工作目录，CMD容器启动时运行命令，等等指令构建镜像；<br>4、Dockerfile编写完成就可以构建镜像了，使用docker build -t 镜像名:tag . 命令来构建镜像，最后一个点是表示当前目录，docker会默认寻找当前目录下的Dockerfile文件来构建镜像，如果不使用默认，可以使用-f参数来指定dockerfile文件，如：docker build -t 镜像名:tag -f /xx/xxx/Dockerfile ；<br>5、使用docker build命令构建之后，docker就会将当前目录下所有的文件发送给docker daemon，顺序执行Dockerfile文件里的指令，在这过程中会生成临时容器，在临时容器里面安装RUN指定的命令，安装成功后，docker底层会使用类似于docker commit命令来将容器保存为镜像，然后删除临时容器，以此类推，一层层的构建镜像，运行临时容器安装软件，直到最后的镜像构建成功。</p><h4 id="Dockerfile构建镜像出现异常，如何排查？"><a href="#Dockerfile构建镜像出现异常，如何排查？" class="headerlink" title="Dockerfile构建镜像出现异常，如何排查？"></a>Dockerfile构建镜像出现异常，如何排查？</h4><p>首先，Dockerfile是一层一层的构建镜像，期间会产生一个或多个临时容器，构建过程中其实就是在临时容器里面安装应用，如果因为临时容器安装应用出现异常导致镜像构建失败，这时容器虽然被清理掉了，但是期间构建的中间镜像还在，那么我们可以根据异常时上一层已经构建好的临时镜像，将临时镜像运行为容器，然后在容器里面运行安装命令来定位具体的异常。</p><h4 id="Dockerfile的基本指令有哪些？"><a href="#Dockerfile的基本指令有哪些？" class="headerlink" title="Dockerfile的基本指令有哪些？"></a>Dockerfile的基本指令有哪些？</h4><p>FROM 指定基础镜像（必须为第一个指令，因为需要指定使用哪个基础镜像来构建镜像）；<br>MAINTAINER 设置镜像作者相关信息，如作者名字，日期，邮件，联系方式等；<br>COPY 复制文件到镜像；<br>ADD 复制文件到镜像（ADD与COPY的区别在于，ADD会自动解压tar、zip、tgz、xz等归档文件，而COPY不会，同时ADD指令还可以接一个url下载文件地址，一般建议使用COPY复制文件即可，文件在宿主机上是什么样子复制到镜像里面就是什么样子这样比较好）；<br>ENV 设置环境变量；<br>EXPOSE 暴露容器进程的端口，仅仅是提示别人容器使用的哪个端口，没有过多作用；<br>VOLUME 数据卷持久化，挂载一个目录；<br>WORKDIR 设置工作目录，如果目录不在，则会自动创建目录；<br>RUN 在容器中运行命令，RUN指令会创建新的镜像层，RUN指令经常被用于安装软件包；<br>CMD 指定容器启动时默认运行哪些命令，如果有多个CMD，则只有最后一个生效，另外，CMD指令可以被docker run之后的参数替换；<br>ENTRYOINT 指定容器启动时运行哪些命令，如果有多个ENTRYOINT，则只有最后一个生效，另外，如果Dockerfile中同时存在CMD和ENTRYOINT，那么CMD或docker run之后的参数将被当做参数传递给ENTRYOINT；</p><h4 id="如何进入容器？使用哪个命令"><a href="#如何进入容器？使用哪个命令" class="headerlink" title="如何进入容器？使用哪个命令"></a>如何进入容器？使用哪个命令</h4><p>进入容器有两种方法：docker attach、docker exec；<br>docker attach命令是attach到容器启动命令的终端，docker exec 是另外在容器里面启动一个TTY终端。</p><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br></pre></td><td class="code"><pre><span class="line">docker run -d centos /bin/bash -c <span class="string">"while true;do sleep 2;echo I_am_a_container;done"</span></span><br><span class="line">3274412d88ca4f1d1292f6d28d46f39c14c733da5a4085c11c6a854d30d1cde0</span><br><span class="line">docker attach 3274412d88ca4f<span class="comment">#attach进入容器</span></span><br><span class="line">Ctrl + c 退出，Ctrl + c会直接关闭容器终端，这样容器没有进程一直在前台运行就会死掉了</span><br><span class="line">Ctrl + pq 退出（不会关闭容器终端停止容器，仅退出）</span><br><span class="line"></span><br><span class="line">docker <span class="built_in">exec</span> -it 3274412d88ca /bin/bash<span class="comment">#exec进入容器</span></span><br><span class="line">[root@3274412d88ca /]<span class="comment"># ps -ef#进入到容器了开启了一个bash进程</span></span><br><span class="line">UID PID PPID C STIME TTY TIME CMD</span><br><span class="line">root 1 0 0 05:31 ? 00:00:01 /bin/bash -c <span class="keyword">while</span> <span class="literal">true</span>;<span class="keyword">do</span> <span class="built_in">sleep</span> 2;<span class="built_in">echo</span> I_am_a_container;<span class="keyword">done</span></span><br><span class="line">root 306 0 1 05:41 pts/0 00:00:00 /bin/bash</span><br><span class="line">root 322 1 0 05:41 ? 00:00:00 /usr/bin/coreutils --coreutils-prog-shebang=<span class="built_in">sleep</span> /usr/bin/sleep 2</span><br><span class="line">root 323 306 0 05:41 pts/0 00:00:00 ps -ef</span><br><span class="line">[root@3274412d88ca /]<span class="comment">#exit#退出容器，仅退出我们自己的bash窗口</span></span><br></pre></td></tr></table></figure><p>小结：attach是直接进入容器启动命令的终端，不会启动新的进程；exec则是在容器里面打开新的终端，会启动新的进程；一般建议已经exec进入容器。</p><h4 id="什么是k8s？说出你的理解"><a href="#什么是k8s？说出你的理解" class="headerlink" title="什么是k8s？说出你的理解"></a>什么是k8s？说出你的理解</h4><p>K8s是kubernetes的简称，其本质是一个开源的容器编排系统，主要用于管理容器化的应用，其目标是让部署容器化的应用简单并且高效（powerful）,Kubernetes提供了应用部署，规划，更新，维护的一种机制。<br>说简单点：k8s就是一个编排容器的系统，一个可以管理容器应用全生命周期的工具，从创建应用，应用的部署，应用提供服务，扩容缩容应用，应用更新，都非常的方便，而且还可以做到故障自愈，所以，k8s是一个非常强大的容器编排系统。</p><h4 id="k8s的组件有哪些，作用分别是什么？"><a href="#k8s的组件有哪些，作用分别是什么？" class="headerlink" title="k8s的组件有哪些，作用分别是什么？"></a>k8s的组件有哪些，作用分别是什么？</h4><p>k8s主要由master节点和node节点构成。master节点负责管理集群，node节点是容器应用真正运行的地方。<br>master节点包含的组件有：kube-api-server、kube-controller-manager、kube-scheduler、etcd。<br>node节点包含的组件有：kubelet、kube-proxy、container-runtime。</p><p>kube-api-server：以下简称api-server，api-server是k8s最重要的核心组件之一，它是k8s集群管理的统一访问入口，提供了RESTful API接口, 实现了认证、授权和准入控制等安全功能；api-server还是其他组件之间的数据交互和通信的枢纽，其他组件彼此之间并不会直接通信，其他组件对资源对象的增、删、改、查和监听操作都是交由api-server处理后，api-server再提交给etcd数据库做持久化存储，只有api-server才能直接操作etcd数据库，其他组件都不能直接操作etcd数据库，其他组件都是通过api-server间接的读取，写入数据到etcd。</p><p>kube-controller-manager：以下简称controller-manager，controller-manager是k8s中各种控制器的的管理者，是k8s集群内部的管理控制中心，也是k8s自动化功能的核心；controller-manager内部包含replication controller、node controller、deployment controller、endpoint controller等各种资源对象的控制器，每种控制器都负责一种特定资源的控制流程，而controller-manager正是这些controller的核心管理者。</p><p>kube-scheduler：以下简称scheduler，scheduler负责集群资源调度，其作用是将待调度的pod通过一系列复杂的调度算法计算出最合适的node节点，然后将pod绑定到目标节点上。shceduler会根据pod的信息，全部节点信息列表，过滤掉不符合要求的节点，过滤出一批候选节点，然后给候选节点打分，选分最高的就是最佳节点，scheduler就会把目标pod安置到该节点。</p><p>Etcd：etcd是一个分布式的键值对存储数据库，主要是用于保存k8s集群状态数据，比如，pod，service等资源对象的信息；etcd可以是单个也可以有多个，多个就是etcd数据库集群，etcd通常部署奇数个实例，在大规模集群中，etcd有5个或7个节点就足够了；另外说明一点，etcd本质上可以不与master节点部署在一起，只要master节点能通过网络连接etcd数据库即可。</p><p>kubelet：每个node节点上都有一个kubelet服务进程，kubelet作为连接master和各node之间的桥梁，负责维护pod和容器的生命周期，当监听到master下发到本节点的任务时，比如创建、更新、终止pod等任务，kubelet 即通过控制docker来创建、更新、销毁容器；<br>每个kubelet进程都会在api-server上注册本节点自身的信息，用于定期向master汇报本节点资源的使用情况。</p><p>kube-proxy：kube-proxy运行在node节点上，在Node节点上实现Pod网络代理，维护网络规则和四层负载均衡工作，kube-proxy会监听api-server中从而获取service和endpoint的变化情况，创建并维护路由规则以提供服务IP和负载均衡功能。简单理解此进程是Service的透明代理兼负载均衡器，其核心功能是将到某个Service的访问请求转发到后端的多个Pod实例上。</p><p>container-runtime：容器运行时环境，即运行容器所需要的一系列程序，目前k8s支持的容器运行时有很多，如docker、rkt或其他，比较受欢迎的是docker，但是新版的k8s已经宣布弃用docker。</p><h4 id="kubelet的功能、作用是什么？（重点，经常会问）"><a href="#kubelet的功能、作用是什么？（重点，经常会问）" class="headerlink" title="kubelet的功能、作用是什么？（重点，经常会问）"></a>kubelet的功能、作用是什么？（重点，经常会问）</h4><p>答：kubelet部署在每个node节点上的，它主要有2个功能：<br>1、节点管理。kubelet启动时会向api-server进行注册，然后会定时的向api-server汇报本节点信息状态，资源使用状态等，这样master就能够知道node节点的资源剩余，节点是否失联等等相关的信息了。master知道了整个集群所有节点的资源情况，这对于 pod 的调度和正常运行至关重要。<br>2、pod管理。kubelet负责维护node节点上pod的生命周期，当kubelet监听到master的下发到自己节点的任务时，比如要创建、更新、删除一个pod，kubelet 就会通过CRI（容器运行时接口）插件来调用不同的容器运行时来创建、更新、删除容器；常见的容器运行时有docker、containerd、rkt等等这些容器运行时，我们最熟悉的就是docker了，但在新版本的k8s已经弃用docker了，k8s1.24版本中已经使用containerd作为容器运行时了。<br>3、容器健康检查。pod中可以定义启动探针、存活探针、就绪探针等3种，我们最常用的就是存活探针、就绪探针，kubelet 会定期调用容器中的探针来检测容器是否存活，是否就绪，如果是存活探针，则会根据探测结果对检查失败的容器进行相应的重启策略；<br>4、Metrics Server资源监控。在node节点上部署Metrics Server用于监控node节点、pod的CPU、内存、文件系统、网络使用等资源使用情况，而kubelet则通过Metrics Server获取所在节点及容器的上的数据。</p><h4 id="kube-api-server的端口是多少？各个pod是如何访问kube-api-server的？"><a href="#kube-api-server的端口是多少？各个pod是如何访问kube-api-server的？" class="headerlink" title="kube-api-server的端口是多少？各个pod是如何访问kube-api-server的？"></a>kube-api-server的端口是多少？各个pod是如何访问kube-api-server的？</h4><p>kube-api-server的端口是8080和6443，前者是http的端口，后者是https的端口，以我本机使用kubeadm安装的k8s为例：<br>在命名空间的kube-system命名空间里，有一个名称为kube-api-master的pod，这个pod就是运行着kube-api-server进程，它绑定了master主机的ip地址和6443端口，但是在default命名空间下，存在一个叫kubernetes的服务，该服务对外暴露端口为443，目标端口6443，这个服务的ip地址是clusterip地址池里面的第一个地址，同时这个服务的yaml定义里面并没有指定标签选择器，也就是说这个kubernetes服务所对应的endpoint是手动创建的，该endpoint也是名称叫做kubernetes，该endpoint的yaml定义里面代理到master节点的6443端口，也就是kube-api-server的IP和端口。这样一来，其他pod访问kube-api-server的整个流程就是：pod创建后嵌入了环境变量，pod获取到了kubernetes这个服务的ip和443端口，请求到kubernetes这个服务其实就是转发到了master节点上的6443端口的kube-api-server这个pod里面。</p><h4 id="k8s中命名空间的作用是什么？"><a href="#k8s中命名空间的作用是什么？" class="headerlink" title="k8s中命名空间的作用是什么？"></a>k8s中命名空间的作用是什么？</h4><p>namespace是kubernetes系统中的一种非常重要的资源，namespace的主要作用是用来实现多套环境的资源隔离，或者说是多租户的资源隔离。<br>k8s通过将集群内部的资源分配到不同的namespace中，可以形成逻辑上的隔离，以方便不同的资源进行隔离使用和管理。不同的命名空间可以存在同名的资源，命名空间为资源提供了一个作用域。<br>可以通过k8s的授权机制，将不同的namespace交给不同的租户进行管理，这样就实现了多租户的资源隔离，还可以结合k8s的资源配额机制，限定不同的租户能占用的资源，例如CPU使用量、内存使用量等等来实现租户可用资源的管理。<br>k8s提供了大量的REST接口，其中有一个是Kubernetes Proxy API接口，简述一下这个Proxy接口的作用，已经怎么使用。</p><p>好的。kubernetes proxy api接口，从名称中可以得知，proxy是代理的意思，其作用就是代理rest请求；Kubernets API server 将接收到的rest请求转发到某个node上的kubelet守护进程的rest接口，由该kubelet进程负责响应。我们可以使用这种Proxy接口来直接访问某个pod，这对于逐一排查pod异常问题很有帮助。<br>下面是一些简单的例子：</p><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line">http://<kube-api-server>:<api-sever-port>/api/v1/nodes/node名称/proxy/pods <span class="comment">#查看指定node的所有pod信息</span></span><br><span class="line">http://<kube-api-server>:<api-sever-port>/api/v1/nodes/node名称/proxy/stats <span class="comment">#查看指定node的物理资源统计信息</span></span><br><span class="line">http://<kube-api-server>:<api-sever-port>/api/v1/nodes/node名称/proxy/spec <span class="comment">#查看指定node的概要信息</span></span><br><span class="line"></span><br><span class="line">http://<kube-api-server>:<api-sever-port>/api/v1/namespace/命名名称/pods/pod名称/pod服务的url/ <span class="comment">#访问指定pod的程序页面</span></span><br><span class="line">http://<kube-api-server>:<api-sever-port>/api/v1/namespace/命名名称/servers/svc名称/url/ <span class="comment">#访问指定server的url程序页面</span></span><br><span class="line"></span><br></pre></td></tr></table></figure><h4 id="pod是什么？"><a href="#pod是什么？" class="headerlink" title="pod是什么？"></a>pod是什么？</h4><p>在kubernetes的世界中，k8s并不直接处理容器，而是使用多个容器共存的理念，这组容器就叫做pod。pod是k8s中可以创建和管理的最小单元，是资源对象模型中由用户创建或部署的最小资源对象模型，其他的资源对象都是用来支撑pod对象功能的，比如，pod控制器就是用来管理pod对象的，service或者imgress资源对象是用来暴露pod引用对象的，persistentvolume资源是用来为pod提供存储等等，简而言之，k8s不会直接处理容器，而是pod，pod才是k8s中可以创建和管理的最小单元，也是基本单元。</p><h4 id="pod的原理是什么？"><a href="#pod的原理是什么？" class="headerlink" title="pod的原理是什么？"></a>pod的原理是什么？</h4><p>在微服务的概念里，一般的，一个容器会被设计为运行一个进程，除非进程本身产生子进程，这样，由于不能将多个进程聚集在同一个单独的容器中，所以需要一种更高级的结构将容器绑定在一起，并将它们作为一个单元进行管理，这就是k8s中pod的背后原理。</p><h4 id="pod有什么特点？"><a href="#pod有什么特点？" class="headerlink" title="pod有什么特点？"></a>pod有什么特点？</h4><pre><code>1、每个pod就像一个独立的逻辑机器，k8s会为每个pod分配一个集群内部唯一的IP地址，所以每个pod都拥有自己的IP地址、主机名、进程等；2、一个pod可以包含1个或多个容器，1个容器一般被设计成只运行1个进程，1个pod只可能运行在单个节点上，即不可能1个pod跨节点运行，pod的生命周期是短暂，也就是说pod可能随时被消亡（如节点异常，pod异常等情况）；2、每一个pod都有一个特殊的被称为"根容器"的pause容器，也称info容器，pause容器对应的镜像属于k8s平台的一部分，除了pause容器，每个pod还包含一个或多个跑业务相关组件的应用容器；3、一个pod中的容器共享network命名空间；4、一个pod里的多个容器共享pod IP，这就意味着1个pod里面的多个容器的进程所占用的端口不能相同，否则在这个pod里面就会产生端口冲突；既然每个pod都有自己的IP和端口空间，那么对不同的两个pod来说就不可能存在端口冲突；5、应该将应用程序组织到多个pod中，而每个pod只包含紧密相关的组件或进程；6、pod是k8s中扩容、缩容的基本单位，也就是说k8s中扩容缩容是针对pod而言而非容器。</code></pre><h4 id="pause容器作用是什么？"><a href="#pause容器作用是什么？" class="headerlink" title="pause容器作用是什么？"></a>pause容器作用是什么？</h4><p>每个pod里运行着一个特殊的被称之为pause的容器，也称根容器，而其他容器则称为业务容器；创建pause容器主要是为了为业务容器提供 Linux命名空间，共享基础：包括 pid、icp、net 等，以及启动 init 进程，并收割僵尸进程；这些业务容器共享pause容器的网络命名空间和volume挂载卷，当pod被创建时，pod首先会创建pause容器，从而把其他业务容器加入pause容器，从而让所有业务容器都在同一个命名空间中，这样可以就可以实现网络共享。pod还可以共享存储，在pod级别引入数据卷volume，业务容器都可以挂载这个数据卷从而实现持久化存储。</p><h4 id="pod的重启策略有哪些？"><a href="#pod的重启策略有哪些？" class="headerlink" title="pod的重启策略有哪些？"></a>pod的重启策略有哪些？</h4><p>pod重启容器策略是指针对pod内所有容器的重启策略，不是重启pod，其可以通过restartPolicy字段配置pod重启容器的策略，如下：</p><pre><code>Always: 当容器终止退出后，总是重启容器，默认策略就是Always。OnFailure: 当容器异常退出，退出状态码非0时，才重启容器。Never: 当容器终止退出，不管退出状态码是什么，从不重启容器。</code></pre><h4 id="pod的镜像拉取策略有哪几种？"><a href="#pod的镜像拉取策略有哪几种？" class="headerlink" title="pod的镜像拉取策略有哪几种？"></a>pod的镜像拉取策略有哪几种？</h4><p>pod镜像拉取策略可以通过imagePullPolicy字段配置镜像拉取策略，主要有3中镜像拉取策略，如下：</p><pre><code>IfNotPresent: 默认值，镜像在node节点宿主机上不存在时才拉取。Always: 总是重新拉取，即每次创建pod都会重新从镜像仓库拉取一次镜像。Never: 永远不会主动拉取镜像，仅使用本地镜像，需要你手动拉取镜像到node节点，如果node节点不存在镜像则pod启动失败。</code></pre><h4 id="pod的存活探针有哪几种？（必须记住3重探测方式，重点，经常问）"><a href="#pod的存活探针有哪几种？（必须记住3重探测方式，重点，经常问）" class="headerlink" title="pod的存活探针有哪几种？（必须记住3重探测方式，重点，经常问）"></a>pod的存活探针有哪几种？（必须记住3重探测方式，重点，经常问）</h4><p>kubernetes可以通过存活探针检查容器是否还在运行，可以为pod中的每个容器单独定义存活探针，kubernetes将定期执行探针，如果探测失败，将杀死容器，并根据restartPolicy策略来决定是否重启容器，kubernetes提供了3种探测容器的存活探针，如下：</p><pre><code>httpGet：通过容器的IP、端口、路径发送http 请求，返回200-400范围内的状态码表示成功。exec：在容器内执行shell命令，根据命令退出状态码是否为0进行判断，0表示健康，非0表示不健康。TCPSocket：与容器的IP、端口建立TCP Socket链接，能建立则说明探测成功，不能建立则说明探测失败。</code></pre><h4 id="存活探针的属性参数有哪几个？"><a href="#存活探针的属性参数有哪几个？" class="headerlink" title="存活探针的属性参数有哪几个？"></a>存活探针的属性参数有哪几个？</h4><p>存活探针的附加属性参数有以下几个：</p><pre><code>initialDelaySeconds：表示在容器启动后延时多久秒才开始探测；periodSeconds：表示执行探测的频率，即间隔多少秒探测一次，默认间隔周期是10秒，最小1秒；timeoutSeconds：表示探测超时时间，默认1秒，最小1秒，表示容器必须在超时时间范围内做出响应，否则视为本次探测失败；successThreshold：表示最少连续探测成功多少次才被认定为成功，默认是1，对于liveness必须是1，最小值是1；failureThreshold：表示连续探测失败多少次才被认定为失败，默认是3，连续3次失败，k8s 将根据pod重启策略对容器做出决定；注意：定义存活探针时，一定要设置initialDelaySeconds属性，该属性为初始延时，如果不设置，默认容器启动时探针就开始探测了，这样可能会存在应用程序还未启动就绪，就会导致探针检测失败，k8s就会根据pod重启策略杀掉容器然后再重新创建容器的莫名其妙的问题。在生产环境中，一定要定义一个存活探针。</code></pre><h4 id="pod的就绪探针有哪几种？（必须记住3重探测方式，重点，经常问）"><a href="#pod的就绪探针有哪几种？（必须记住3重探测方式，重点，经常问）" class="headerlink" title="pod的就绪探针有哪几种？（必须记住3重探测方式，重点，经常问）"></a>pod的就绪探针有哪几种？（必须记住3重探测方式，重点，经常问）</h4><p>我们知道，当一个pod启动后，就会立即加入service的endpoint ip列表中，并开始接收到客户端的链接请求，假若此时pod中的容器的业务进程还没有初始化完毕，那么这些客户端链接请求就会失败，为了解决这个问题，kubernetes提供了就绪探针来解决这个问题的。<br>在pod中的容器定义一个就绪探针，就绪探针周期性检查容器，如果就绪探针检查失败了，说明该pod还未准备就绪，不能接受客户端链接，则该pod将从endpoint列表中移除，被剔除了service就不会把请求分发给该pod，然后就绪探针继续检查，如果随后容器就绪，则再重新把pod加回endpoint列表。k8s提供了3种就绪探针，如下：</p><pre><code>httpGet：通过容器的IP、容器的端口以及路径来发送http get请求，返回200-400范围内的状态码表示请求成功。exec：在容器内执行shell命令，它根据shell命令退出状态码是否为0进行判断，0表示健康，非0表示不健康。TCPSocket：通过容器的IP、端口建立TCP Socket链接，能正常建立链接，则说明探针成功，不能正常建立链接，则探针失败。</code></pre><h4 id="就绪探针的属性参数有哪些"><a href="#就绪探针的属性参数有哪些" class="headerlink" title="就绪探针的属性参数有哪些"></a>就绪探针的属性参数有哪些</h4><p>就绪探针的附加属性参数有以下几个：</p><pre><code>initialDelaySeconds：延时秒数，即容器启动多少秒后才开始探测，不写默认容器启动就探测；periodSeconds ：执行探测的频率（秒），默认为10秒，最低值为1；timeoutSeconds ：超时时间，表示探测时在超时时间内必须得到响应，负责视为本次探测失败，默认为1秒，最小值为1；failureThreshold ：连续探测失败的次数，视为本次探测失败，默认为3次，最小值为1次；successThreshold ：连续探测成功的次数，视为本次探测成功，默认为1次，最小值为1次；</code></pre><h4 id="就绪探针与存活探针区别是什么？"><a href="#就绪探针与存活探针区别是什么？" class="headerlink" title="就绪探针与存活探针区别是什么？"></a>就绪探针与存活探针区别是什么？</h4><p>两者作用不一样，存活探针是将检查失败的容器杀死，创建新的启动容器来保持pod正常工作；<br>就绪探针是，当就绪探针检查失败，并不重启容器，而是将pod移出endpoint，就绪探针确保了service中的pod都是可用的，确保客户端只与正常的pod交互并且客户端永远不会知道系统存在问题。</p><h4 id="简单讲一下-pod创建过程"><a href="#简单讲一下-pod创建过程" class="headerlink" title="简单讲一下 pod创建过程"></a>简单讲一下 pod创建过程</h4><pre><code>情况一、如果面试官问的是使用kubectl run命令创建的pod，可以这样说：#注意：kubectl run 在旧版本中创建的是deployment，但在新的版本中创建的是pod则其创建过程不涉及deployment如果是单独的创建一个pod，则其创建过程是这样的：1、首先，用户通过kubectl或其他api客户端工具提交需要创建的pod信息给apiserver；2、apiserver验证客户端的用户权限信息，验证通过开始处理创建请求生成pod对象信息，并将信息存入etcd，然后返回确认信息给客户端；3、apiserver开始反馈etcd中pod对象的变化，其他组件使用watch机制跟踪apiserver上的变动；4、scheduler发现有新的pod对象要创建，开始调用内部算法机制为pod分配最佳的主机，并将结果信息更新至apiserver；5、node节点上的kubelet通过watch机制跟踪apiserver发现有pod调度到本节点，尝试调用docker启动容器，并将结果反馈apiserver；6、apiserver将收到的pod状态信息存入etcd中。至此，整个pod创建完毕。情况二、如果面试官说的是使用deployment来创建pod，则可以这样回答：1、首先，用户使用kubectl create命令或者kubectl apply命令提交了要创建一个deployment资源请求；2、api-server收到创建资源的请求后，会对客户端操作进行身份认证，在客户端的~/.kube文件夹下，已经设置好了相关的用户认证信息，这样api-server会知道我是哪个用户，并对此用户进行鉴权，当api-server确定客户端的请求合法后，就会接受本次操作，并把相关的信息保存到etcd中，然后返回确认信息给客户端。3、apiserver开始反馈etcd中过程创建的对象的变化，其他组件使用watch机制跟踪apiserver上的变动。4、controller-manager组件会监听api-server的信息，controller-manager是有多个类型的，比如Deployment Controller, 它的作用就是负责监听Deployment，此时Deployment Controller发现有新的deployment要创建，那么它就会去创建一个ReplicaSet，一个ReplicaSet的产生，又被另一个叫做ReplicaSet Controller监听到了，紧接着它就会去分析ReplicaSet的语义，它了解到是要依照ReplicaSet的template去创建Pod, 它一看这个Pod并不存在，那么就新建此Pod，当Pod刚被创建时，它的nodeName属性值为空，代表着此Pod未被调度。5、调度器Scheduler组件开始介入工作，Scheduler也是通过watch机制跟踪apiserver上的变动，发现有未调度的Pod，则根据内部算法、节点资源情况，pod定义的亲和性反亲和性等等，调度器会综合的选出一批候选节点，在候选节点中选择一个最优的节点，然后将pod绑定该该节点，将信息反馈给api-server。6、kubelet组件布署于Node之上，它也是通过watch机制跟踪apiserver上的变动，监听到有一个Pod应该要被调度到自身所在Node上来，kubelet首先判断本地是否在此Pod，如果不存在，则会进入创建Pod流程，创建Pod有分为几种情况，第一种是容器不需要挂载外部存储，则相当于直接docker run把容器启动，但不会直接挂载docker网络，而是通过CNI调用网络插件配置容器网络，如果需要挂载外部存储，则还要调用CSI来挂载存储。kubelet创建完pod，将信息反馈给api-server，api-servier将pod信息写入etcd。7、Pod建立成功后，ReplicaSet Controller会对其持续进行关注，如果Pod因意外或被我们手动退出，ReplicaSet Controller会知道，并创建新的Pod，以保持replicas数量期望值。以上即使pod的调度过程。</code></pre><h4 id="简单描述一下pod的终止过程"><a href="#简单描述一下pod的终止过程" class="headerlink" title="简单描述一下pod的终止过程"></a>简单描述一下pod的终止过程</h4><pre><code>1、用户向apiserver发送删除pod对象的命令；2、apiserver中的pod对象信息会随着时间的推移而更新，在宽限期内（默认30s），pod被视为dead；3、将pod标记为terminating状态；4、kubectl在监控到pod对象为terminating状态了就会启动pod关闭过程；5、endpoint控制器监控到pod对象的关闭行为时将其从所有匹配到此endpoint的server资源endpoint列表中删除；6、如果当前pod对象定义了preStop钩子处理器，则在其被标记为terminating后会意同步的方式启动执行；7、pod对象中的容器进程收到停止信息；8、宽限期结束后，若pod中还存在运行的进程，那么pod对象会收到立即终止的信息；9、kubelet请求apiserver将此pod资源的宽限期设置为0从而完成删除操作，此时pod对用户已不可见。</code></pre><h4 id="pod的生命周期有哪几种？"><a href="#pod的生命周期有哪几种？" class="headerlink" title="pod的生命周期有哪几种？"></a>pod的生命周期有哪几种？</h4><p>pod生命周期有的5种状态（也称5种相位），如下：</p><pre><code>Pending（挂起）：API server已经创建pod，但是该pod还有一个或多个容器的镜像没有创建，包括正在下载镜像的过程；Running（运行中）：Pod内所有的容器已经创建，且至少有一个容器处于运行状态、正在启动括正在重启状态；Succeed（成功）：Pod内所有容器均已退出，且不会再重启；Failed（失败）：Pod内所有容器均已退出，且至少有一个容器为退出失败状态Unknown（未知）：某于某种原因apiserver无法获取该pod的状态，可能由于网络通行问题导致；</code></pre><h4 id="pod一致处于pending状态一般有哪些情况，怎么排查？（重点，持续更新）"><a href="#pod一致处于pending状态一般有哪些情况，怎么排查？（重点，持续更新）" class="headerlink" title="pod一致处于pending状态一般有哪些情况，怎么排查？（重点，持续更新）"></a>pod一致处于pending状态一般有哪些情况，怎么排查？（重点，持续更新）</h4><p>（这个问题被问到的概率非常大）<br>答：一个pod一开始创建的时候，它本身就是会处于pending状态，这时可能是正在拉取镜像，正在创建容器的过程。<br>如果等了一会发现pod一直处于pending状态，那么我们可以使用kubectl describe命令查看一下pod的Events详细信息。一般可能会有这么几种情况导致pod一直处于pending状态：<br>1、调度器调度失败。Scheduer调度器无法为pod分配一个合适的node节点。而这又会有很多种情况，比如，node节点处在cpu、内存压力，导致无节点可调度；pod定义了资源请求，没有node节点满足资源请求；node节点上有污点而pod没有定义容忍；pod中定义了亲和性或反亲和性而没有节点满足这些亲和性或反亲和性；以上是调度器调度失败的几种情况。<br>2、pvc、pv无法动态创建。如果因为pvc或pv无法动态创建，那么pod也会一直处于pending状态，比如要使用StatefulSet 创建redis集群，因为粗心大意，定义的storageClassName名称写错了，那么会造成无法创建pvc，这种情况pod也会一直处于pending状态，或者，即使pvc是正常创建了，但是由于某些异常原因导致动态供应存储无法正常创建pv，那么这种情况pod也会一直处于pending状态。</p><h4 id="pod的钩子函数有哪几种，作用是什么？"><a href="#pod的钩子函数有哪几种，作用是什么？" class="headerlink" title="pod的钩子函数有哪几种，作用是什么？"></a>pod的钩子函数有哪几种，作用是什么？</h4><h4 id="pod的初始化容器是干什么的？"><a href="#pod的初始化容器是干什么的？" class="headerlink" title="pod的初始化容器是干什么的？"></a>pod的初始化容器是干什么的？</h4><p>init container，初始化容器用于在启动应用容器之前完成应用容器所需要的前置条件，初始化容器本质上和应用容器是一样的，但是初始化容器是仅允许一次就结束的任务，初始化容器具有两大特征：</p><pre><code>1、初始化容器必须运行完成直至结束，若某初始化容器运行失败，那么kubernetes需要重启它直到成功完成；2、初始化容器必须按照定义的顺序执行，当且仅当前一个初始化容器成功之后，后面的一个初始化容器才能运行；</code></pre><h4 id="pod的资源请求、限制如何定义？"><a href="#pod的资源请求、限制如何定义？" class="headerlink" title="pod的资源请求、限制如何定义？"></a>pod的资源请求、限制如何定义？</h4><p>pod的资源请求、资源限制可以直接在pod中定义，主要包括两块内容，limits，限制pod能使用的最大cpu和内存，requests，pod启动时申请的cpu和内存。</p><pre><code>resources:#资源配额 limits:#限制最大资源，上限 cpu: 2#CPU限制，单位是code数 memory: 2G#内存最大限制 requests:#请求资源（最小，下限） cpu: 1#CPU请求，单位是code数 memory: 500G#内存最小请求</code></pre><h4 id="pod的定义中有个command和args参数，这两个参数不会和docker镜像的entrypointc冲突吗？"><a href="#pod的定义中有个command和args参数，这两个参数不会和docker镜像的entrypointc冲突吗？" class="headerlink" title="pod的定义中有个command和args参数，这两个参数不会和docker镜像的entrypointc冲突吗？"></a>pod的定义中有个command和args参数，这两个参数不会和docker镜像的entrypointc冲突吗？</h4><p>不会。<br>在pod中定义的command参数用于指定容器的启动命令列表，如果不指定，则默认使用Dockerfile打包时的启动命令，args参数用于容器的启动命令需要的参数列表；<br>特别说明：<br>kubernetes中的command、args其实是实现覆盖dockerfile中的ENTRYPOINT的功能的。当</p><pre><code>1、如果command和args均没有写，那么使用Dockerfile的配置；2、如果command写了但args没写，那么Dockerfile默认的配置会被忽略，执行指定的command；3、如果command没写但args写了，那么Dockerfile中的ENTRYPOINT的会被执行，使用当前args的参数；4、如果command和args都写了，那么Dockerfile会被忽略，执行输入的command和args。</code></pre><h4 id="标签及标签选择器是什么，如何使用？"><a href="#标签及标签选择器是什么，如何使用？" class="headerlink" title="标签及标签选择器是什么，如何使用？"></a>标签及标签选择器是什么，如何使用？</h4><p>标签是键值对类型，标签可以附加到任何资源对象上，主要用于管理对象，查询和筛选。标签常被用于标签选择器的匹配度检查，从而完成资源筛选；一个资源可以定义一个或多个标签在其上面。</p><p>标签选择器，标签要与标签选择器结合在一起，标签选择器允许我们选择标记有特定标签的资源对象子集，如pod，并对这些特定标签的pod进行查询，删除等操作。<br>标签和标签选择器最重要的使用之一在于，在deployment中，在pod模板中定义pod的标签，然后在deployment定义标签选择器，这样就通过标签选择器来选择哪些pod是受其控制的，service也是通过标签选择器来关联哪些pod最后其服务后端pod。</p><h4 id="service是如何与pod关联的？"><a href="#service是如何与pod关联的？" class="headerlink" title="service是如何与pod关联的？"></a>service是如何与pod关联的？</h4><p>答案是通过标签选择器，每一个由deployment创建的pod都带有标签，这样，service就可以定义标签选择器来关联哪些pod是作为其后端了，就是这样，service就与pod管联在一起了。</p><h4 id="service的域名解析格式、pod的域名解析格式"><a href="#service的域名解析格式、pod的域名解析格式" class="headerlink" title="service的域名解析格式、pod的域名解析格式"></a>service的域名解析格式、pod的域名解析格式</h4><p>service的DNS域名表示格式为<servicename>.<namespace>.svc.<clusterdomain>，servicename是service的名称，namespace是service所处的命名空间，clusterdomain是k8s集群设置的域名后缀，一般默认为 cluster.local</clusterdomain></namespace></servicename></p><p>pod的DNS域名格式为：<pod-ip>.<namespace>.pod.<clusterdomain> ，其中，pod-ip需要使用-将ip直接的点替换掉，namespace为pod所在的命名空间，clusterdomain是k8s集群设置的域名后缀，一般默认为 cluster.local ，演示如下：10-244-1-223.default.pod.cluster.local<br>对于deployment、daemonsets等创建的pod，还还可以通过<pod-ip>.<deployment-name>.<namespace>.svc.<clusterdomain> 这样的域名访问。</clusterdomain></namespace></deployment-name></pod-ip></clusterdomain></namespace></pod-ip></p><h4 id="service的类型有哪几种"><a href="#service的类型有哪几种" class="headerlink" title="service的类型有哪几种"></a>service的类型有哪几种</h4><p>service的类型一般有4中，分别是：</p><pre><code>ClusterIP：表示service仅供集群内部使用，默认值就是ClusterIP类型NodePort：表示service可以对外访问应用，会在每个节点上暴露一个端口，这样外部浏览器访问地址为：任意节点的IP：NodePort就能连上service了LoadBalancer：表示service对外访问应用，这种类型的service是公有云环境下的service，此模式需要外部云厂商的支持，需要有一个公网IP地址ExternalName：这种类型的service会把集群外部的服务引入集群内部，这样集群内直接访问service就可以间接的使用集群外部服务了一般情况下，service都是ClusterIP类型的，通过ingress接入的外部流量。</code></pre><h4 id="一个应用pod是如何发现service的，或者说，pod里面的容器用于是如何连接service的？"><a href="#一个应用pod是如何发现service的，或者说，pod里面的容器用于是如何连接service的？" class="headerlink" title="一个应用pod是如何发现service的，或者说，pod里面的容器用于是如何连接service的？"></a>一个应用pod是如何发现service的，或者说，pod里面的容器用于是如何连接service的？</h4><p>答：有两种方式，一种是通过环境变量，另一种是通过service的dns域名方式。<br>1、环境变量：当pod被创建之后，k8s系统会自动为容器注入集群内有效的service名称和端口号等信息为环境变量的形式，这样容器应用直接通过取环境变量值就能访问service了，如curl http://${WEBAPP_SERVICE_HOST}:{WEBAPP_SERVICE_PORT}<br>2、DNS方式：使用dns域名解析的前提是k8s集群内有DNS域名解析服务器，默认k8s中会有一个CoreDNS作为k8s集群的默认DNS服务器提供域名解析服务器；service的DNS域名表示格式为<servicename>.<namespace>.svc.<clusterdomain>，servicename是service的名称，namespace是service所处的命名空间，clusterdomain是k8s集群设置的域名后缀，一般默认为 cluster.local ，这样容器应用直接通过service域名就能访问service了，如wget <a href="http://svc-deployment-nginx.default.svc.cluster.local:80，另外，service的port端口如果定义了名称，那么port也可以通过DNS进行解析，格式为：">http://svc-deployment-nginx.default.svc.cluster.local:80，另外，service的port端口如果定义了名称，那么port也可以通过DNS进行解析，格式为：</a><em><portname>.</portname></em><protocol>.<servicename>.<namespace>.svc.<clusterdomain></clusterdomain></namespace></servicename></protocol></clusterdomain></namespace></servicename></p><h4 id="如何创建一个service代理外部的服务，或者换句话来说，在k8s集群内的应用如何访问外部的服务，如数据库服务，缓存服务等"><a href="#如何创建一个service代理外部的服务，或者换句话来说，在k8s集群内的应用如何访问外部的服务，如数据库服务，缓存服务等" class="headerlink" title="如何创建一个service代理外部的服务，或者换句话来说，在k8s集群内的应用如何访问外部的服务，如数据库服务，缓存服务等?"></a>如何创建一个service代理外部的服务，或者换句话来说，在k8s集群内的应用如何访问外部的服务，如数据库服务，缓存服务等?</h4><p>答：可以通过创建一个没有标签选择器的service来代理集群外部的服务。<br>1、创建service时不指定selector标签选择器，但需要指定service的port端口、端口的name、端口协议等，这样创建出来的service因为没有指定标签选择器就不会自动创建endpoint；<br>2、手动创建一个与service同名的endpoint，endpoint中定义外部服务的IP和端口，endpoint的名称一定要与service的名称一样，端口协议也要一样，端口的name也要与service的端口的name一样，不然endpoint不能与service进行关联。<br>完成以上两步，k8s会自动将service和同名的endpoint进行关联，这样，k8s集群内的应用服务直接访问这个service就可以相当于访问外部的服务了。</p><h4 id="service、endpoint、kube-proxys三种的关系是什么？"><a href="#service、endpoint、kube-proxys三种的关系是什么？" class="headerlink" title="service、endpoint、kube-proxys三种的关系是什么？"></a>service、endpoint、kube-proxys三种的关系是什么？</h4><p>service：在kubernetes中，service是一种为一组功能相同的pod提供单一不变的接入点的资源。当service被建立时，service的IP和端口不会改变，这样外部的客户端（也可以是集群内部的客户端）通过service的IP和端口来建立链接，这些链接会被路由到提供该服务的任意一个pod上。通过这样的方式，客户端不需要知道每个单独提供服务的pod地址，这样pod就可以在集群中随时被创建或销毁。<br>endpoint：service维护一个叫endpoint的资源列表，endpoint资源对象保存着service关联的pod的ip和端口。从表面上看，当pod消失，service会在endpoint列表中剔除pod，当有新的pod加入，service就会将pod ip加入endpoint列表；但是正在底层的逻辑是，endpoint的这种自动剔除、添加、更新pod的地址其实底层是由endpoint controller控制的，endpoint controller负责监听service和对应的pod副本的变化，如果监听到service被删除，则删除和该service同名的endpoint对象，如果监听到新的service被创建或者修改，则根据该service信息获取得相关pod列表，然后创建或更新service对应的endpoint对象，如果监听到pod事件，则更新它所对应的service的endpoint对象。<br>kube-proxy：kube-proxy运行在node节点上，在Node节点上实现Pod网络代理，维护网络规则和四层负载均衡工作，kube-proxy会监听api-server中从而获取service和endpoint的变化情况，创建并维护路由规则以提供服务IP和负载均衡功能。简单理解此进程是Service的透明代理兼负载均衡器，其核心功能是将到某个Service的访问请求转发到后端的多个Pod实例上。</p><h4 id="无头service和普通的service有什么区别，无头service使用场景是什么？"><a href="#无头service和普通的service有什么区别，无头service使用场景是什么？" class="headerlink" title="无头service和普通的service有什么区别，无头service使用场景是什么？"></a>无头service和普通的service有什么区别，无头service使用场景是什么？</h4><p>答：无头service没有cluster ip，在定义service时将 service.spec.clusterIP：None，就表示创建的是无头service。<br>普通的service是用于为一组后端pod提供请求连接的负载均衡，让客户端能通过固定的service ip地址来访问pod，这类的pod是没有状态的，同时service还具有负载均衡和服务发现的功能。普通service跟我们平时使用的nginx反向代理很相识。<br>但是，试想这样一种情况，有6个redis pod ,它们相互之间要通信并要组成一个redis集群，不在需要所谓的service负载均衡，这时无头service就是派上用场了，无头service由于没有cluster ip，kube-proxy就不会处理它也就不会对它生成规则负载均衡，无头service直接绑定的是pod 的ip。无头service仍会有标签选择器，有标签选择器就会有endpoint资源。<br>使用场景：无头service一般用于有状态的应用场景，如Kaka集群、Redis集群等，这类pod之间需要相互通信相互组成集群，不在需要所谓的service负载均衡。</p><h4 id="deployment怎么扩容或缩容？"><a href="#deployment怎么扩容或缩容？" class="headerlink" title="deployment怎么扩容或缩容？"></a>deployment怎么扩容或缩容？</h4><p>答：直接修改pod副本数即可，可以通过下面的方式来修改pod副本数：<br>1、直接修改yaml文件的replicas字段数值，然后kubectl apply -f xxx.yaml来实现更新；<br>2、使用kubectl edit deployment xxx 修改replicas来实现在线更新；<br>3、使用kubectl scale –replicas=5 deployment/deployment-nginx命令来扩容缩容。</p><h4 id="deployment的更新升级策略有哪些？"><a href="#deployment的更新升级策略有哪些？" class="headerlink" title="deployment的更新升级策略有哪些？"></a>deployment的更新升级策略有哪些？</h4><p>答：deployment的升级策略主要有两种。<br>1、Recreate 重建更新：这种更新策略会杀掉所有正在运行的pod，然后再重新创建的pod；<br>2、rollingUpdate 滚动更新：这种更新策略，deployment会以滚动更新的方式来逐个更新pod，同时通过设置滚动更新的两个参数maxUnavailable、maxSurge来控制更新的过程。</p><h4 id="deployment的滚动更新策略有两个特别主要的参数，解释一下它们是什么意思？"><a href="#deployment的滚动更新策略有两个特别主要的参数，解释一下它们是什么意思？" class="headerlink" title="deployment的滚动更新策略有两个特别主要的参数，解释一下它们是什么意思？"></a>deployment的滚动更新策略有两个特别主要的参数，解释一下它们是什么意思？</h4><p>答：deployment的滚动更新策略，rollingUpdate 策略，主要有两个参数，maxUnavailable、maxSurge。</p><pre><code>maxUnavailable：最大不可用数，maxUnavailable用于指定deployment在更新的过程中不可用状态的pod的最大数量，maxUnavailable的值可以是一个整数值，也可以是pod期望副本的百分比，如25%，计算时向下取整。maxSurge：最大激增数，maxSurge指定deployment在更新的过程中pod的总数量最大能超过pod副本数多少个，maxUnavailable的值可以是一个整数值，也可以是pod期望副本的百分比，如25%，计算时向上取整。</code></pre><h4 id="deployment更新的命令有哪些？"><a href="#deployment更新的命令有哪些？" class="headerlink" title="deployment更新的命令有哪些？"></a>deployment更新的命令有哪些？</h4><p>答：可以通过三种方式来实现更新deployment。<br>1、直接修改yaml文件的镜像版本，然后kubectl apply -f xxx.yaml来实现更新；<br>2、使用kubectl edit deployment xxx 实现在线更新；<br>3、使用kubectl set image deployment/nginx busybox=busybox nginx=nginx:1.9.1 命令来更新。</p><h4 id="简述一下deployment的更新过程"><a href="#简述一下deployment的更新过程" class="headerlink" title="简述一下deployment的更新过程?"></a>简述一下deployment的更新过程?</h4><p>deployment是通过控制replicaset来实现，由replicaset真正创建pod副本，每更新一次deployment，都会创建新的replicaset，下面来举例deployment的更新过程：<br>假设要升级一个nginx-deployment的版本镜像为nginx:1.9，deployment的定义滚动更新参数如下：</p><pre><code>replicas: 3deployment.spec.strategy.type: RollingUpdatemaxUnavailable：25%maxSurge：25%</code></pre><p>通过计算我们得出，3*25%=0.75，maxUnavailable是向下取整，则maxUnavailable=0，maxSurge是向上取整，则maxSurge=1，所以我们得出在整个deployment升级镜像过程中，不管旧的pod和新的pod是如何创建消亡的，pod总数最大不能超过3+maxSurge=4个，最大pod不可用数3-maxUnavailable=3个。</p><p>现在具体讲一下deployment的更新升级过程：<br>使用kubectl set image deployment/nginx nginx=nginx:1.9 –record 命令来更新；<br>1、deployment创建一个新的replaceset，先新增1个新版本pod，此时pod总数为4个，不能再新增了，再新增就超过pod总数4个了；旧=3，新=1，总=4；<br>2、减少一个旧版本的pod，此时pod总数为3个，这时不能再减少了，再减少就不满足最大pod不可用数3个了；旧=2，新=1，总=3；<br>3、再新增一个新版本的pod，此时pod总数为4个，不能再新增了；旧=2，新=2，总=4；<br>4、减少一个旧版本的pod，此时pod总数为3个，这时不能再减少了；旧=1，新=2，总=3；<br>5、再新增一个新版本的pod，此时pod总数为4个，不能再新增了；旧=1，新=3，总=4；<br>6、减少一个旧版本的pod，此时pod总数为3个，更新完成，pod都是新版本了；旧=0，新=3，总=3；</p><h4 id="deployment的回滚使用什么命令"><a href="#deployment的回滚使用什么命令" class="headerlink" title="deployment的回滚使用什么命令"></a>deployment的回滚使用什么命令</h4><p>在升级deployment时kubectl set image 命令加上 –record 参数可以记录具体的升级历史信息，使用kubectl rollout history deployment/deployment-nginx 命令来查看指定的deployment升级历史记录，如果需要回滚到某个指定的版本，可以使用kubectl rollout undo deployment/deployment-nginx –to-revision=2 命令来实现。</p><h4 id="讲一下都有哪些存储卷，作用分别是什么"><a href="#讲一下都有哪些存储卷，作用分别是什么" class="headerlink" title="讲一下都有哪些存储卷，作用分别是什么?"></a>讲一下都有哪些存储卷，作用分别是什么?</h4><table><thead><tr><th align="center">卷</th><th align="center">作用</th><th align="center">常用场景</th></tr></thead><tbody><tr><td align="center">emptyDir</td><td align="center">用于存储临时数据的简单空目录</td><td align="center">一个pod中的多个容器需要共享彼此的数据 ，emptyDir的数据随着容器的消亡也会销毁</td></tr><tr><td align="center">hostPath</td><td align="center">用于将目录从工作节点的文件系统挂载到pod中</td><td align="center">不常用，缺点是，pod的调度不是固定的，也就是当pod消失后deployment重新创建一个pod，而这pod如果不是被调度到之前pod的节点，那么该pod就不能访问之前的数据</td></tr><tr><td align="center">configMap</td><td align="center">用于将非敏感的数据保存到键值对中，使用时可以使用作为环境变量、命令行参数arg，存储卷被pods挂载使用</td><td align="center">将应用程序的不敏感配置文件创建为configmap卷，在pod中挂载configmap卷，可是实现热更新</td></tr><tr><td align="center">secret</td><td align="center">主要用于存储和管理一些敏感数据，然后通过在 Pod 的容器里挂载 Volume 的方式或者环境变量的方式访问到这些 Secret 里保存的信息了，pod会自动解密Secret 的信息</td><td align="center">将应用程序的账号密码等敏感信息通过secret卷的形式挂载到pod中使用</td></tr><tr><td align="center">downwardApi</td><td align="center">主要用于暴露pod元数据，如pod的名字</td><td align="center">pod中的应用程序需要指定pod的name等元数据，就可以通过downwardApi 卷的形式挂载给pod使用</td></tr><tr><td align="center">projected</td><td align="center">这是一种特殊的卷，用于将上面这些卷一次性的挂载给pod使用</td><td align="center">将上面这些卷一次性的挂载给pod使用</td></tr><tr><td align="center">pvc</td><td align="center">pvc是存储卷声明</td><td align="center">通常会创建pvc表示对存储的申请，然后在pod中使用pvc</td></tr><tr><td align="center">网络存储卷</td><td align="center">pod挂载网络存储卷，这样就能将数据持久化到后端的存储里</td><td align="center">常见的网络存储卷有nfs存储、glusterfs 卷、ceph rbd存储卷</td></tr></tbody></table><h4 id="pv的访问模式有哪几种"><a href="#pv的访问模式有哪几种" class="headerlink" title="pv的访问模式有哪几种"></a>pv的访问模式有哪几种</h4><p>pv的访问模式有3种，如下：</p><pre><code>ReadWriteOnce，简写：RWO表示，只仅允许单个节点以读写方式挂载；ReadOnlyMany，简写：ROX表示，可以被许多节点以只读方式挂载；ReadWriteMany，简写：RWX表示，可以被多个节点以读写方式挂载；</code></pre><h4 id="pv的回收策略有哪几种"><a href="#pv的回收策略有哪几种" class="headerlink" title="pv的回收策略有哪几种"></a>pv的回收策略有哪几种</h4><p>主要有2中回收策略：retain 保留、delete 删除。<br>Retain：保留，该策略允许手动回收资源，当删除PVC时，PV仍然存在，PV被视为已释放，管理员可以手动回收卷。<br>Delete：删除，如果Volume插件支持，删除PVC时会同时删除PV，动态卷默认为Delete，目前支持Delete的存储后端包括AWS EBS，GCE PD，Azure Disk，OpenStack Cinder等。<br>Recycle：回收，如果Volume插件支持，Recycle策略会对卷执行rm -rf清理该PV，并使其可用于下一个新的PVC，但是本策略将来会被弃用，目前只有NFS和HostPath支持该策略。（这种策略已经被废弃，不用记）</p><h4 id="在pv的生命周期中，一般有几种状态"><a href="#在pv的生命周期中，一般有几种状态" class="headerlink" title="在pv的生命周期中，一般有几种状态"></a>在pv的生命周期中，一般有几种状态</h4><p>pv一共有4中状态，分别是：<br>创建pv后，pv的的状态有以下4种：Available（可用）、Bound（已绑定）、Released（已释放）、Failed（失败）</p><pre><code>Available，表示pv已经创建正常，处于可用状态；Bound，表示pv已经被某个pvc绑定，注意，一个pv一旦被某个pvc绑定，那么该pvc就独占该pv，其他pvc不能再与该pv绑定；Released，表示pvc被删除了，pv状态就会变成已释放；Failed，表示pv的自动回收失败；</code></pre><h4 id="存储类的资源回收策略"><a href="#存储类的资源回收策略" class="headerlink" title="存储类的资源回收策略:"></a>存储类的资源回收策略:</h4><p>主要有2中回收策略，delete 删除，默认就是delete策略、retain 保留。<br>Retain：保留，该策略允许手动回收资源，当删除PVC时，PV仍然存在，PV被视为已释放，管理员可以手动回收卷。<br>Delete：删除，如果Volume插件支持，删除PVC时会同时删除PV，动态卷默认为Delete，目前支持Delete的存储后端包括AWS EBS，GCE PD，Azure Disk，OpenStack Cinder等。</p><p>注意：使用存储类动态创建的pv默认继承存储类的回收策略，当然当pv创建后你也可以手动修改pv的回收策略。</p><h4 id="怎么使一个node脱离集群调度，比如要停机维护单又不能影响业务应用"><a href="#怎么使一个node脱离集群调度，比如要停机维护单又不能影响业务应用" class="headerlink" title="怎么使一个node脱离集群调度，比如要停机维护单又不能影响业务应用"></a>怎么使一个node脱离集群调度，比如要停机维护单又不能影响业务应用</h4><p>crodon背后的原理其实就是打污点<br>使用kubectl drain 命令</p><h4 id="pv存储空间不足怎么扩容"><a href="#pv存储空间不足怎么扩容" class="headerlink" title="pv存储空间不足怎么扩容?"></a>pv存储空间不足怎么扩容?</h4><p>一般的，我们会使用动态分配存储资源，在创建storageclass时指定参数 allowVolumeExpansion：true，表示允许用户通过修改pvc申请的存储空间自动完成pv的扩容，当增大pvc的存储空间时，不会重新创建一个pv，而是扩容其绑定的后端pv。这样就能完成扩容了。但是allowVolumeExpansion这个特性只支持扩容空间不支持减少空间。</p><h4 id="k8s生产中遇到什么特别影响深刻的问题吗，问题排查解决思路是怎么样的？（重点）"><a href="#k8s生产中遇到什么特别影响深刻的问题吗，问题排查解决思路是怎么样的？（重点）" class="headerlink" title="k8s生产中遇到什么特别影响深刻的问题吗，问题排查解决思路是怎么样的？（重点）"></a>k8s生产中遇到什么特别影响深刻的问题吗，问题排查解决思路是怎么样的？（重点）</h4><p>（此问题被问到的概率高达90%，所以可以自己准备几个自己在生产环境中遇到的问题进行讲解）</p><p>答：前端的lb负载均衡服务器上的keepalived出现过脑裂现象。<br>1、当时问题现象是这样的，vip同时出现在主服务器和备服务器上，但业务上又没受到影响；<br>2、这时首先去查看备服务器上的keepalived日志，发现有日志信息显示凌晨的时候备服务器出现了vrrp协议超时，所以才导致了备服务器接管了vip；查看主服务器上的keepalived日志，没有发现明显的报错信息，继续查看主服务器和备服务器上的keepalived进程状态，都是running状态的；查看主服务器上检测脚本所检测的进程，其进程也是正常的，也就是说主服务器根本没有成功执行检测脚本（成功执行检查脚本是会kill掉keepalived进程，脚本里面其实就是配置了检查nginx进程是否存活，如果检查到nginx不存活则kill掉keepalived，这样来实现备服务器接管vip）；<br>3、排查服务器上的防火墙、selinux，防火墙状态和selinux状态都是关闭着的；<br>4、使用tcpdump工具在备服务器上进行抓取数据包分析，分析发现，现在确实是备接管的vip，也确实是备服务器也在对外发送vrrp心跳包，所以现在外部流量应该都是流入备服务器上的vip；<br>5、怀疑：主服务器上设置的vrrp心跳包时间间隔太长，以及检测脚本设置的检测时间设置不合理导致该问题；<br>6、修改vrrp协议的心跳包时间间隔，由原来的2秒改成1秒就发送一次心跳包；检测脚本的检测时间也修改短一点，同时还修改检测脚本的检测失败的次数，比如连续检测2次失败才认定为检测失败；<br>7、重启主备上的keepalived，现在keepalived是正常的，主服务器上有vip，备服务器上没有vip；<br>8、持续观察：第二天又发现keepalived出现过脑裂现象，vip又同时出现在主服务器和备服务器上，又是凌晨的时候备服务器显示vrrp心跳包超时，所以才导致备服务器接管了vip；<br>9、同样的时间，都是凌晨，vrrp协议超时；很奇怪，很有理由怀疑是网络问题，询问第三方厂家上层路由器是否禁止了vrrp协议，第三方厂家回复，没有禁止vrrp协议；<br>10、百度、看官方文档求解；<br>11、百度、看官网文档得知，keepalived有2种传播模式，一种是组播模式，一种是单播模式，keepalived默认在组播模式下工作，主服务器会往主播地址224.0.0.18发送心跳包，当局域网内有多个keepalived实例的时候，如果都用主播模式，会存在冲突干扰的情况，所以官方建议使用单播模式通信，单播模式就是点对点通行，即主向备服务器一对一的发送心跳包；<br>12、将keepalived模式改为单播模式，继续观察，无再发生脑裂现象。问题得以解决。</p><p>答：测试环境二进制搭建etcd集群，etcd集群出现2个leader的现象。<br>1、问题现象就是：刚搭建的k8s集群，是测试环境的，搭建完成之后发现，使用kubectl get nodes 显示没有资源，kubectl get namespace 一会能正常显示全部的命名空间，一会又显示不了命名空间，这种奇怪情况。<br>2、当时经验不是很足，第一点想到的是不是因为网络插件calico没装导致的，但是想想，即使没有安装网络插件，最多是node节点状态是notready，也不可能是没有资源发现呀；<br>3、然后想到etcd数据库，k8s的资源都是存储在etcd数据库中的；<br>4、查看etcd进程服务的启动状态，发现etcd服务状态是处于running状态，但是日志有大量的报错信息，日志大概报错信息就是集群节点的id不匹配，存在冲突等等报错信息；<br>5、使用etcdctl命令查看etcd集群的健康状态，发现集群是health状态，但是居然显示有2个leader，这很奇怪（当初安装etcd的时候其实也只是简单看到了集群是健康状态，然后没注意到有2个leader，也没太关注etcd服务进程的日志报错信息，以为etcd集群状态是health状态就可以了）<br>6、现在etcd出现了2个leader，肯定是存在问题的；<br>7、全部检测一遍etcd的各个节点的配置文件，确认配置文件里面各个参数配置都没有问题，重启etcd集群，报错信息仍未解决，仍然存在2个leader；<br>8、尝试把其中一个leader节点踢出集群，然后再重新添加它进入集群，仍然是报错，仍然显示有2个leader；<br>9、尝试重新生成etcd的证书，重新颁发etcd的证书，问题仍然存在，仍然显示有2个leader；日志仍是报错集群节点的id不匹配，存在冲突；<br>10、计算etcd命令的MD5值，确保各个节点的etcd命令是相同的，确保在scp传输的时候没有损耗等等，问题仍未解决；<br>11、无解，请求同事，架构师介入帮忙排查问题，仍未解决；<br>12、删除全部etcd相关的文件，重新部署etcd集群，etcd集群正常了，现在只有一个leader，使用命令kubectl get nodes 查看节点，也能正常显示了；<br>13、最终问题的原因也没有定位出来，只能怀疑是环境问题了，由于是刚部署的k8s测试环境，etcd里面没有数据，所以可以删除重新创建etcd集群，如果是线上环境的etcd集群出现这种问题，就不能随便删除etcd集群了，必须要先进行数据备份才能进行其他方法的处理。</p><h4 id="etcd集群节点可以设置为偶数个吗，为什么要设置为基数个呢？"><a href="#etcd集群节点可以设置为偶数个吗，为什么要设置为基数个呢？" class="headerlink" title="etcd集群节点可以设置为偶数个吗，为什么要设置为基数个呢？"></a>etcd集群节点可以设置为偶数个吗，为什么要设置为基数个呢？</h4><p>不能，也不建议这么设置。<br>因为在软件的概念了，有个默认的规则，那就是集群的节点数量必须是基数个，因为这涉及到一个选举机制的问题。<br>（待补充）</p><h4 id="etcd集群节点之间是怎么同步数据的？"><a href="#etcd集群节点之间是怎么同步数据的？" class="headerlink" title="etcd集群节点之间是怎么同步数据的？"></a>etcd集群节点之间是怎么同步数据的？</h4><p>（待补充）</p><h4 id="pod的网络是怎么实现的，比如在node节点上ping一个pod的ip，这个网络流程是什么验证的？"><a href="#pod的网络是怎么实现的，比如在node节点上ping一个pod的ip，这个网络流程是什么验证的？" class="headerlink" title="pod的网络是怎么实现的，比如在node节点上ping一个pod的ip，这个网络流程是什么验证的？"></a>pod的网络是怎么实现的，比如在node节点上ping一个pod的ip，这个网络流程是什么验证的？</h4><p>这块涉及到k8s的网络，优点难（待补充）</p><h4 id="一个用户请求流量是如何进入k8s集群内部的？"><a href="#一个用户请求流量是如何进入k8s集群内部的？" class="headerlink" title="一个用户请求流量是如何进入k8s集群内部的？"></a>一个用户请求流量是如何进入k8s集群内部的？</h4><h4 id="用户访问我们的k8s集群里面的应用网站，出现500报错，你是如何排查这种问题的？"><a href="#用户访问我们的k8s集群里面的应用网站，出现500报错，你是如何排查这种问题的？" class="headerlink" title="用户访问我们的k8s集群里面的应用网站，出现500报错，你是如何排查这种问题的？"></a>用户访问我们的k8s集群里面的应用网站，出现500报错，你是如何排查这种问题的？</h4><h4 id="k8s后端存储使用的是什么？"><a href="#k8s后端存储使用的是什么？" class="headerlink" title="k8s后端存储使用的是什么？"></a>k8s后端存储使用的是什么？</h4><h4 id="你们的服务发布怎么做的？"><a href="#你们的服务发布怎么做的？" class="headerlink" title="你们的服务发布怎么做的？"></a>你们的服务发布怎么做的？</h4>]]></content>
<categories>
<category> 面试题 </category>
</categories>
<tags>
<tag> docker kubernetes </tag>
</tags>
</entry>
<entry>
<title>Hello World</title>
<link href="/post/4a17b156.html"/>
<url>/post/4a17b156.html</url>
<content type="html"><![CDATA[<p>Welcome to <a href="https://hexo.io/">Hexo</a>! This is your very first post. Check <a href="https://hexo.io/docs/">documentation</a> for more info. If you get any problems when using Hexo, you can find the answer in <a href="https://hexo.io/docs/troubleshooting.html">troubleshooting</a> or you can ask me on <a href="https://github.com/hexojs/hexo/issues">GitHub</a>.</p><h2 id="Quick-Start"><a href="#Quick-Start" class="headerlink" title="Quick Start"></a>Quick Start</h2><h3 id="Create-a-new-post"><a href="#Create-a-new-post" class="headerlink" title="Create a new post"></a>Create a new post</h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">$ hexo new <span class="string">"My New Post"</span></span><br></pre></td></tr></table></figure><p>More info: <a href="https://hexo.io/docs/writing.html">Writing</a></p><h3 id="Run-server"><a href="#Run-server" class="headerlink" title="Run server"></a>Run server</h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">$ hexo server</span><br></pre></td></tr></table></figure><p>More info: <a href="https://hexo.io/docs/server.html">Server</a></p><h3 id="Generate-static-files"><a href="#Generate-static-files" class="headerlink" title="Generate static files"></a>Generate static files</h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">$ hexo generate</span><br></pre></td></tr></table></figure><p>More info: <a href="https://hexo.io/docs/generating.html">Generating</a></p><h3 id="Deploy-to-remote-sites"><a href="#Deploy-to-remote-sites" class="headerlink" title="Deploy to remote sites"></a>Deploy to remote sites</h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">$ hexo deploy</span><br></pre></td></tr></table></figure><p>More info: <a href="https://hexo.io/docs/one-command-deployment.html">Deployment</a></p>]]></content>
</entry>
</search>