diff --git a/AI/mechine learning/AWS.md b/AI/mechine learning/AWS.md new file mode 100644 index 0000000..fea068c --- /dev/null +++ b/AI/mechine learning/AWS.md @@ -0,0 +1,129 @@ +# AWS + +> 来源：原 mongodb 集合 `t_blog` · 整理日期：2026-08-25 +> 分类 ID：`2022050510233200000000000005` · 排序：6 · 文章数：7 + +## 目录 + +1. [S3](#s3) +2. [EC2](#ec2) +3. [Route 53](#route-53) +4. [VPC](#vpc) +5. [AWS Storage Gateway](#aws-storage-gateway) +6. [Amazon Kinesis](#amazon-kinesis) +7. [AWS　STS](#aws-sts) + +--- + +## 1. S3 + +bid: `2022050510233300000000000006` + +### simple storage service +--- +[Price文档](https://aws.amazon.com/cn/s3/pricing/) +S3的收费内容，包括： +存储，请求（http请求数量），数据传输（宽带费用），复制（跨区域和不跨区域），管理（额外的高级管理功能） + + +### Enable Requester Pays +--- +[官方文档](https://docs.aws.amazon.com/zh_cn/AmazonS3/latest/userguide/RequesterPaysBuckets.html) +作为SAP考试中的一题，重要考察的是：存储桶的拥有者和访问者分开付费。两个不同的付费账户，访问者需要身份验证。 +关键词：**Enable Requester Pays**，**AWS credentials** + +### Replicating objects +--- +[官方文档](https://docs.aws.amazon.com/AmazonS3/latest/userguide/replication.html#crr-scenario) +**Cross-Region Replication** 跨区域复制 **CRR** + +**Same-Region Replication** 同区域复制 **SRR** + +--- + +## 2. EC2 + +bid: `2022050510458100000000000007` + + + +--- + +## 3. Route 53 + +bid: `2022050510575300000000000008` + + + +--- + +## 4. VPC + +bid: `2022050511086300000000000009` + +### Amazon Virtual Private Cloud +--- +私有云 +[官方文档](https://docs.aws.amazon.com/zh_cn/vpc/?id=docs_gateway) + +PVC的CIDR是 16位， +PVC的子网的CIDR是24位， +同一个区域的两个VPC，最好的解决方式是peering connection，并在路由表中添加路由 + +### VPC peering +--- +  VPC 对等连接是两个 VPC 之间的网络连接，通过此连接，您可以使用私有 IPv4 地址或 IPv6 地址在两个 VPC 之间路由流量。这两个 VPC 中的实例可以彼此通信，就像它们在同一网络中一样。您可以在自己的 VPC 之间创建 VPC 对等连接，或者在自己的 VPC 与其他AWS账户中的 VPC 之间创建连接。VPC 可位于不同区域内（也称为区域间 VPC 对等连接） +  AWS使用 VPC 的现有基础设施来创建 VPC 对等连接；该连接既不是网关也不是 VPN 连接，并且不依赖某一单独的物理硬件。没有单点通信故障也没有带宽瓶颈。 +  创建 VPC 对等连接，无需付费。通过对等连接进行数据传输需要付费。 +  要将私有 IPv4 流量从实例发送到对等 VPC 中的实例，必须向与实例所在子网关联的路由表添加路由。此路由指向 VPC 对等连接中对等 VPC 的 CIDR 块（或 CIDR 块的一部分），并指定 VPC 对等连接作为目标。 +### AWS Transit Gateway +--- +[中转网关工作原理](https://docs.aws.amazon.com/zh_cn/vpc/latest/tgw/how-transit-gateways-work.html) +中转网关是网络中转中心，您可用它来互连 Virtual Private Cloud (VPC) 和本地网络. +中转网关独立存在，有中转网关路由表，可以挂载VPC，AWS Direct Connect，对等连接的另一个Transit Gateway，VPN链接，和第三方设备 +中转网关既可以共享，也可以通过CloudWatch和CloudTrail进行监控。 +### AWS PrivateLink +--- +  AWS PrivateLink 是一项具有高可用性的可扩展技术，支持您将您的 VPC 私密地连接到支持的 AWS 服务、由其他 AWS 账户托管的服务（VPC 终端节点服务）以及支持的 AWS Marketplace 合作伙伴服务。您无需使用互联网网关、NAT 设备、公有 IP 地址、AWS Direct Connect 连接或 AWS Site-to-Site VPN 连接，就能与该服务通信。因此，您可以控制可从 VPC 访问的特定 API 终端节点、站点和服务。 + +  请区分终端节点和终端节点服务。 + +  私有链接通过终端节点来实现，终端节点包括： +接口终端节点： +网关终端节点： +网关负载均衡器终端节点： + +--- + +## 5. AWS Storage Gateway + +bid: `2022050513596500000000000010` + +**提供几乎不受限制的云存储的本地应用程序访问权限** +[官方文档](https://aws.amazon.com/cn/storagegateway/?nc1=h_ls) + +--- + +## 6. Amazon Kinesis + +bid: `2022050514188900000000000011` + +对标于flume，Kafka，和flink的分布式云计算模式。 +[官方文档](https://aws.amazon.com/cn/kinesis/) +**Amazon Kinesis Data Streams** 其实和flume很像 +  日志采集传输，sink +**Amazon Kinesis Data Firehose** 其实和kafka很像 +  消息队列，存储 +**Amazon Kinesis Data Analytics** 其实和flink很像 +  流式计算 + +--- + +## 7. AWS　STS + +bid: `2022050911184000000000000004` + + +AWS Security Token Service (STS) + +--- diff --git a/AI/mechine learning/Azure.md b/AI/mechine learning/Azure.md new file mode 100644 index 0000000..6ee8bfc --- /dev/null +++ b/AI/mechine learning/Azure.md @@ -0,0 +1,154 @@ +# Azure + +> 来源：原 mongodb 集合 `t_blog` · 整理日期：2026-08-25 +> 分类 ID：`2022052309468900000000000004` · 排序：8 · 文章数：8 + +## 目录 + +1. [Iot Hub Endpoint](#iot-hub-endpoint) +2. [Iot Hub Message routing](#iot-hub-message-routing) +3. [Azure IoT Hub Device Provisioning Service (DPS)](#azure-iot-hub-device-provisioning-service-dps) +4. [Batch Shipyard](#batch-shipyard) +5. [Azure system](#azure-system) +6. [pricing](#pricing) +7. [Azure IoT Edge](#azure-iot-edge) +8. [pvc](#pvc) + +--- + +## 1. Iot Hub Endpoint + +bid: `2022052309469000000000000009` + +### endpoints +--- +[IoT Hub endpoints](https://docs.microsoft.com/en-us/azure/iot-hub/iot-hub-devguide-endpoints) + +## IoT Hub names + You can find the hostname of the IoT hub that hosts your endpoints in the portal on your hub's Overview page. + By default, the DNS name of an IoT hub looks like: {your iot hub name}.azure-devices.net. + +## List of built-in IoT Hub endpoints + 1. Device identity management + 2. Device twin management + 3. Jobs management + 4. Device endpoints + 5. Service endpoints + 6. Resource provider. + +## Custom endpoints + 1. Azure Storage containers + 2. Event Hubs + 3. Service Bus Queues + 4. Service Bus Topics + + +## Endpoint Health + +## Field gateways + In an IoT solution, a field gateway sits between your devices and your IoT Hub endpoints. + It is typically located close to your devices. + You can use Azure IoT Edge to implement a field gateway. + IoT Edge offers functionality such as multiplexing communications from multiple devices onto the same IoT Hub connection. + +--- + +## 2. Iot Hub Message routing + +bid: `2022052310025600000000000010` + +Message routing +--- +[Message routing](https://docs.microsoft.com/en-us/azure/iot-hub/iot-hub-devguide-messages-d2c) + +--- + +## 3. Azure IoT Hub Device Provisioning Service (DPS) + +bid: `2022052310265300000000000011` + +### Azure IoT Hub Device Provisioning Service (DPS) +--- +[DPS](https://docs.microsoft.com/en-us/azure/iot-dps/?WT.mc_id=Portal-Microsoft_Azure_IotHub) + +## what is + Microsoft Azure provides a rich set of integrated public cloud services for all your IoT solution needs. + The IoT Hub Device Provisioning Service (DPS) is a helper service for IoT Hub that enables zero-touch, just-in-time provisioning to the right IoT hub without requiring human intervention. + DPS enables the provisioning of millions of devices in a secure and scalable manner. + +## + +--- + +## 4. Batch Shipyard + +bid: `2022052313361500000000000012` + +## Batch Shipyard +--- +[doc](https://batch-shipyard.readthedocs.io/en/latest/00-introduction/) + +--- + +## 5. Azure system + +bid: `2022052313512900000000000013` + +1.active directory +2.subscriptions +3.Resource groups +4. + +azure 基本上是个网格体系 + +--- + +## 6. pricing + +bid: `2022052314413800000000000015` + +## Pricing Options +--- +[doc](https://azure.microsoft.com/ja-jp/pricing/details/iot-hub/#purchase-options) + +--- + +## 7. Azure IoT Edge + +bid: `2022052410596000000000000017` + +## Modules +--- +[doc](https://docs.microsoft.com/en-us/azure/iot-edge/iot-edge-modules?view=iotedge-2020-11) + + IoT Edge modules are Docker containers deployed to IoT Edge devices. + They can communicate with other modules or send data to the IoT Edge runtime. + Azure IoT Edge lets you deploy and manage business logic on the edge in the form of modules. + Azure IoT Edge modules are the smallest unit of computation managed by IoT Edge, and can contain Azure services (such as Azure Stream Analytics) or your own solution-specific code. + To understand how modules are developed, deployed, and maintained, consider the four conceptual elements of a module: + +## Routes +--- +[doc](https://docs.microsoft.com/ja-jp/azure/iot-edge/module-composition?view=iotedge-2020-11#declare-routes) + + +## IoT Edge deployments +--- +[doc](https://docs.microsoft.com/ja-jp/azure/iot-edge/module-deployment-monitoring?view=iotedge-2020-11) + + IoT Edge deployments configure sets of IoT Edge devices to run IoT Edge modules. + Each deployment continuously ensures that all matching devices are running the specified set of modules, even when new devices are created or are modified to match the target condition. + + Two modules are required in every deployment manifest: $edgeAgent, and $edgeHub. + + These modules are part of the IoT Edge runtime that manages the IoT Edge device and the modules running on it. + +--- + +## 8. pvc + +bid: `2022110910113500000000000002` + + + +--- diff --git a/AI/mechine learning/Golang.md b/AI/mechine learning/Golang.md new file mode 100644 index 0000000..c1b3c01 --- /dev/null +++ b/AI/mechine learning/Golang.md @@ -0,0 +1,199 @@ +# Golang + +> 来源：原 mongodb 集合 `t_blog` · 整理日期：2026-08-25 +> 分类 ID：`2023022315480800000000000001` · 排序：12 · 文章数：4 + +## 目录 + +1. [3. grpc xds](#3-grpc-xds) +2. [2. grpc health check](#2-grpc-health-check) +3. [1. grpc protoc](#1-grpc-protoc) +4. [4. Go](#4-go) + +--- + +## 1. 3. grpc xds + +bid: `2023022315480900000000000020` + +该写点什么么... + +--- + +## 2. 2. grpc health check + +bid: `2023022315484500000000000019` + +## + +--- + +## 3. 1. grpc protoc + +bid: `2023022315507600000000000021` + +## base consepts + +- protobuf + +我们可以查看官方文档 [protobuf guides](https://protobuf.dev/programming-guides/proto3/) + +简单来说就是一种以 .proto 结尾文件，遵循protocol buffer language 语法，其中包含一个或者多个message和service。 + +**notice_service.proto** + + syntax = "proto3"; + + package notice.service.v1; + + option go_package ="violin-notice/pkg/service/notice.service.v1"; + + message NoticeMessage { + + }; + + message NoticeResponse {}; + + service NoticeService { + rpc SendNotice(NoticeMessage) returns (NoticeResponse) {} + } + +- protoc +[protoc guides](https://github.com/bufbuild/protoc-gen-validate) + +作为可执行程序，其作用是将上面的我们定义的.proto文件转换成对应语言的grpc 可用的文件，我们通过对这些文件进行扩展来实现我们想要的场景。 + + protoc --go_out=./gen --go_opt=paths=source_relative --go-grpc_out=./gen --go-grpc_opt=paths=source_relative notice_service.proto + +执行上面命令会生成go语言的两个文件 + + notice_service_grpc.pb.go + notice_service.pb.go + +我们只需要自己写一个notice_service.go 来扩展上述两个文件即可。 + +**package notice_service_v1** + + import ( + "context" + "gopkg.in/gomail.v2" + "log" + "violin-home.cn/common/logs" + ) + + type NoticeService struct { + UnimplementedNoticeServiceServer + } + + func New() *NoticeService { + return &NoticeService{} + } + + + func (*NoticeService) SendNotice( + ctx context.Context, msg *NoticeMessage) (*NoticeResponse, error) { + + // to write logic + return &NoticeResponse{}, nil + } + + + ## 如何使用grpc + + grpc 存在client和server + +--- + +## 4. 4. Go + +bid: `2023030213489100000000000022` + +## 1. 概述 +一些简单的概念介绍可以通过下面网站学习到。 +[golang 菜鸟教程](https://www.runoob.com/go/go-tutorial.html) + +## 2. package + +golang的包管理模式是树形的，并且有以下规约： +**1** +树形结构的根节点是main，即项目根目录。 +**2** +文件中的包定义 一定是和该文件所处的文件夹相同 +**3** +文件中定义的函数，如果是像作为第三方包引用，函数的首字母必须大写 + + # violin-controller 工程为例 https://github.com/simple321vip/violin-controller + ls + main.go controller.go controller_test.go 都是 根目录下的文件，所以他们的package 都是 main + 请注意 包 的名字只能是该文件夹的名字，并不包括父级路径 + +**4 引包** +引包 包括第三方包 和 项目自定义包 +在mod模式下，第三方包存在 \$GOPATH/pkg/mod +而自定义包 引入的时候直接从采用 项目相对路径的方式引入 + +## 3. 变量与指针 + +变量分为 值变量和指针变量 + +## 4. 函数 + +**1. main()** 函数 + +程序入口函数 + +**2. init()** 函数 + +每一个源文件都可以包含一个init函数，init意为初始化，也表明init函数会在main函数执行之前执行。 + +**3. go func()** 函数 + +并发编程 即异步 + +**4. func() {}()** 匿名函数 + +匿名函数可以通过变量指向匿名函数，可以匿名函数直接执行 + + // 声明一个函数变量 + f := func() int { + return 1 + } + + // 调用函数 + f() + + // 也可以直接执行匿名函数 + func() int { + return 1 + }() + +**5. func sample() func() int {}** 通过匿名函数实现闭包 + + package main + + import "fmt" + + func getSequence() func() int { + i:=0 + return func() int { + i+=1 + return i + } + } + + func main(){ + /* nextNumber 为一个函数，函数 i 为 0 */ + nextNumber := getSequence() + + /* 调用 nextNumber 函数，i 变量自增 1 并返回 */ + fmt.Println(nextNumber()) + fmt.Println(nextNumber()) + fmt.Println(nextNumber()) + + /* 创建新的函数 nextNumber1，并查看结果 */ + nextNumber1 := getSequence() + fmt.Println(nextNumber1()) + fmt.Println(nextNumber1()) + } + +--- diff --git a/AI/mechine learning/Java and Spring.md b/AI/mechine learning/Java and Spring.md new file mode 100644 index 0000000..c0248d7 --- /dev/null +++ b/AI/mechine learning/Java and Spring.md @@ -0,0 +1,659 @@ +# Java and Spring + +> 来源：原 mongodb 集合 `t_blog` · 整理日期：2026-08-25 +> 分类 ID：`00000000000002` · 排序：1 · 文章数：14 + +## 目录 + +1. [Springboot AbstractApplicationContext](#springboot-abstractapplicationcontext) +2. [Map Set List](#map-set-list) +3. [Java8 AQS](#java8-aqs) +4. [Java8 Stream](#java8-stream) +5. [Spring superinterface](#spring-superinterface) +6. [Springboot DefaultSingletonBeanRegistry](#springboot-defaultsingletonbeanregistry) +7. [Springboot SpringApplication](#springboot-springapplication) +8. [Springboot AbstractBeanFactory](#springboot-abstractbeanfactory) +9. [Springboot AbstractAutowireCapableBeanFactory](#springboot-abstractautowirecapablebeanfactory) +10. [Springboot AbstractBeanDefinition](#springboot-abstractbeandefinition) +11. [Springboot ConfigurationClassPostProcessor](#springboot-configurationclasspostprocessor) +12. [Spring ASM](#spring-asm) +13. [PostProcessorRegistrationDelegate](#postprocessorregistrationdelegate) +14. [Spring Aop](#spring-aop) + +--- + +## 1. Springboot AbstractApplicationContext + +bid: `00000000000003` + +## AbstractApplicationContext + + AbstractApplicationContext 是 SpringBoot的 核心应用上下文父类。 + +## x.1 properties + +### beanFactoryPostProcessors + +### environment + +## x.2 methods + +### refresh + + refresh 是 Springboot启动中核心方法。 + +- prepareRefresh +- obtainFreshBeanFactory +- prepareBeanFactory +- postProcessBeanFactory +- invokeBeanFactoryPostProcessors +- registerBeanPostProcessors +- onRefresh +- finishBeanFactoryInitialization +- finishRefresh + +--- + +## 2. Map Set List + +bid: `2022051816085000000000000006` + +### 1. Summary + + 我们在开发过程在，最常见的三种数据存储结构就是 Map Set 和List了 + + 这三种结构最明显的特征就是Map 是键值，Set是对象存储唯一，List是有序数组 + + +### Map + + 键值存储，主键不允许重复 + + 添加元素 使用put方法，如果key重复，则value被覆盖 + +### Set + + 对象存储，对象不允许重复 + + /** + * if this set did not already contain the specified element will return {@code true} + * f this set already contains the element, the call leaves the set + * unchanged and returns {@code false} + */ + public boolean add(E e) + +### List + + list是由数组构成的，这就意味着，list是有顺序的，因为数组在内存中是一段连续的内存。 + +--- + +## 3. Java8 AQS + +bid: `2022052314143400000000000014` + +## AQ + +--- + +## 4. Java8 Stream + +bid: `2022060810550500000000000022` + +## S + +--- + +## 5. Spring superinterface + +bid: `2022120915183100000000000001` + +## summary + + +## 1. Aware(感知) + +Spring Ioc 是解耦行为，我们的业务代码其实是没有感知或者意识到spring框架的存在。如果我们需要使用spring Ioc中的资源时候，我们就需要有意识的去获取这个资源，而Aware 就是这样的存在。 + + @Service + public class AppContextAware implements ApplicationContextAware { + ApplicationContext applicationContext; + + public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { + this.applicationContext=applicationContext; + } + + public void hello(){ + //user为容器中存在的bean + User user = applicationContext.getBean("user", User.class); + System.out.println(user); + + //获取容器的环境、User.name为设置好的属性 + Environment environment = applicationContext.getEnvironment(); + String property = environment.getProperty("User.name"); + System.out.println(" 属性："+property); + } + } + + 一些常用的Aware interface + BeanNameAware + ApplicationContextAware + ResourceLoaderAware + EnvironmentAware + + + +## 2. BeanFactory + +BeanFactory 提供了获取bean和判断bean的方法，包括 + + getBean(String beanName) + getBean(String beanName, Class requiredType) + getBean(Class requiredType) + containsBean(String name) + isSingleton(String name) + isPrototype(String name) + sTypeMatch(String name) + getType(String name) + String[] getAliases(String name); + +## 3. BeanPostProcessor + +## 4. BeanFactoryPostProcessor + +## 5. ApplicationContext + +## 6. InitializingBean + +--- + +## 6. Springboot DefaultSingletonBeanRegistry + +bid: `2022121513519200000000000002` + +## DefaultSingletonBeanRegistry + +DefaultSingletonBeanRegistry 是Springboot bean 自动装配的核心实现类。 +顾名思义，是默认的单例bean 注册器。 + +## x.1 properties + +### dependentBeanMap + + 存放(依赖对象key -> 被依赖Set)的 ConcurrentHashMap + private final Map> dependentBeanMap = new ConcurrentHashMap<>(64); + +### dependenciesForBeanMap + + 存放(被依赖对象key -> 依赖Set)的 ConcurrentHashMap + private final Map> dependenciesForBeanMap = new ConcurrentHashMap<>(64); +### + +## x.2 methods + +### registerDependentBean + +我们知道Spring DI 依赖注入，此方法就是依赖注入的核心组成。注意，这段逻辑是加锁的，即存在并行处理逻辑。 +Springboot 在 AbstractApplicationContext 进行 refresh 操作时候，在最后一步会实例化bean，参照AbstractApplicationContext.finishBeanFactoryInitialization 方法，此方法的流程我们会在xxx讲解。源码如下 + + + /** + * Register a dependent bean for the given bean。 + */ + public void registerDependentBean(String beanName, String dependentBeanName) { + String canonicalName = canonicalName(beanName); + synchronized (this.dependentBeanMap) { + Set dependentBeans = + this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8)); + if (!dependentBeans.add(dependentBeanName)) { + return; + } + } + + synchronized (this.dependenciesForBeanMap) { + Set dependenciesForBean = + this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8)); + dependenciesForBean.add(canonicalName); + } + + } + +DI 在此处的实现逻辑可以通过下面例子来通俗说明： + ① A对象 依赖 B对象 + ② A对象 依赖 C对象 + ③ D对象 依赖 B对象 + 所以 必须要提前先把 B 对象和 C对象进行实例化后,才能 创建A对象和 D对象。 +我们从RootBeanDefinition中获取 dependsOn的数组，遍历调用registerDependentBean方法 +参数beanName是依赖对象，即 B 或者 C，参数dependentBeanName是被依赖对象A +1. 传入参数是 (B，A) 时，为 B 创建一个 LinkedHashSet，并在该Set中存放A, 并把 B -> Set的映射关系放入dependentBeanMap中。 +紧接着 为 A 创建一个 LinkedHashSet， 并在该Set中存放B，并把 A -> Set的映射关系放入dependenciesForBeanMap中。 +2. 传入参数是 (C, A) 时，为 C 创建一个 LinkedHashSet，并在该Set中存放A, 并把 C -> Set的映射关系放入dependentBeanMap中。 +因为 dependenciesForBeanMap 已经存在了 A -> Set这个映射，我们只需将 C 也存入这个Set就可以。 +3. 传入参数是 (B, D) 时，因为 dependentBeanMap 已经存在了 B -> Set这个映射，我们只需将 D 也存入这个Set就可以。 +紧接着 为 D 创建一个 LinkedHashSet， 并在该Set中存放B，并把 D -> Set的映射关系放入dependenciesForBeanMap中。 + +`注意` 依赖和被依赖总是成对出现的，dependentBeans.add(dependentBeanName) 返回 false，视为添加失败，即视为已经存在，根据 依赖和被依赖总是成对出现的，所以后面dependenciesForBean.add(canonicalName) 这部分就没必要执行了，因为执行了也没有意义，所以直接 return了。毕竟dependenciesForBean中已经存在了canonicalName。 + +--- + +## 7. Springboot SpringApplication + +bid: `2022121513597200000000000003` + +## SpringApplication + +## x.1 properties + +### sources + +### environment + +### webApplicationType + +### + +## x.2 methods + +### run + +1. 创建 DefaultBootstrapContext +2. 获取 SpringApplicationRunListeners +3. 转换 ApplicationArguments 将commandLine args +4. 装备环境 ConfigurableEnvironment +5. 配置忽略bean情报 configureIgnoreBeanInfo +6. 创建 ApplicationContext +7. 准备 ApplicationContext prepareContext +设置上下文环境，加载source +8. 刷新 ApplicationContext +9. 刷新后处理 + +--- + +## 8. Springboot AbstractBeanFactory + +bid: `2022121515315000000000000004` + +## AbstractBeanFactory + + +## x.2 methods + +### doGetBean +AbstractBeanFactory 的核心方法 doGetBean，doGetBean方法是由getBean调用的，如果有dependsOn存在，就会将注册依赖， 然调用getBean(dep)，从而形成了递归操作。 +当不存dependsOn的时候mbd.isSingleton 时候，就会调用 getSingleton方法，子类会回调createBean(beanName, mbd, args)方法，去创建bean。 + +源码 + + protected T doGetBean(String name, @Nullable Class requiredType) { + String beanName = transformedBeanName(name); + RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); + checkMergedBeanDefinition(mbd, beanName, args); + + // Guarantee initialization of beans that the current bean depends on. + String[] dependsOn = mbd.getDependsOn(); + if (dependsOn != null) { + for (String dep : dependsOn) { + if (isDependent(beanName, dep)) { + throw new BeanCreationException(mbd.getResourceDescription(), beanName, + "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'"); + } + registerDependentBean(dep, beanName); + try { + getBean(dep); + } + catch (NoSuchBeanDefinitionException ex) { + throw new BeanCreationException(mbd.getResourceDescription(), beanName, + "'" + beanName + "' depends on missing bean '" + dep + "'", ex); + } + } + } + + // Create bean instance. + if (mbd.isSingleton()) { + sharedInstance = getSingleton(beanName, () -> { + try { + return createBean(beanName, mbd, args); + } + catch (BeansException ex) { + // Explicitly remove instance from singleton cache: It might have been put there + // eagerly by the creation process, to allow for circular reference resolution. + // Also remove any beans that received a temporary reference to the bean. + destroySingleton(beanName); + throw ex; + } + }); + beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); + } + } + +--- + +## 9. Springboot AbstractAutowireCapableBeanFactory + +bid: `2022121523309700000000000005` + +## AbstractAutowireCapableBeanFactory + +父类是AbstractBeanFactory，实现了AutowireCapableBeanFactory 的方法，其中最主要的还是createBean方法。 +源码 + + /** + * Central method of this class: creates a bean instance, + * populates the bean instance, applies post-processors, etc. + * @see #doCreateBean + */ + @Override + protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) + throws BeanCreationException { + + if (logger.isTraceEnabled()) { + logger.trace("Creating instance of bean '" + beanName + "'"); + } + RootBeanDefinition mbdToUse = mbd; + + // Make sure bean class is actually resolved at this point, and + // clone the bean definition in case of a dynamically resolved Class + // which cannot be stored in the shared merged bean definition. + Class resolvedClass = resolveBeanClass(mbd, beanName); + if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) { + mbdToUse = new RootBeanDefinition(mbd); + mbdToUse.setBeanClass(resolvedClass); + } + + // Prepare method overrides. + try { + mbdToUse.prepareMethodOverrides(); + } + catch (BeanDefinitionValidationException ex) { + throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(), + beanName, "Validation of method overrides failed", ex); + } + + try { + // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance. + Object bean = resolveBeforeInstantiation(beanName, mbdToUse); + if (bean != null) { + return bean; + } + } + catch (Throwable ex) { + throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName, + "BeanPostProcessor before instantiation of bean failed", ex); + } + + try { + Object beanInstance = doCreateBean(beanName, mbdToUse, args); + if (logger.isTraceEnabled()) { + logger.trace("Finished creating instance of bean '" + beanName + "'"); + } + return beanInstance; + } + catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) { + // A previously detected exception with proper bean creation context already, + // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry. + throw ex; + } + catch (Throwable ex) { + throw new BeanCreationException( + mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex); + } + } + +--- + +## 10. Springboot AbstractBeanDefinition + +bid: `2022121523361800000000000006` + +## AbstractBeanDefinition + +AbstractBeanDefinition 定义了 一个bean的各种描述。 + +## x.1 + +### String[] dependsOn + +### Resource resource + +### + +--- + +## 11. Springboot ConfigurationClassPostProcessor + +bid: `2022121612282000000000000009` + +## ConfigurationClassPostProcessor + +这一节主要讲的是ConfigurationClassPostProcessor和他的一些生态。 +他的生态有 +- ConfigurationClassParser 真正的处理者。 +- ComponentScanAnnotationParser 扫描classpath，把beanName加入到registry的beanDefinitionMap中。 +- doProcessConfigurationClass 是该 postProcessor最核心的处理方法 + + /** + * Apply processing and build a complete {@link ConfigurationClass} by reading the + * annotations, members and methods from the source class. This method can be called + * multiple times as relevant sources are discovered. + * @param configClass the configuration class being build + * @param sourceClass a source class + * @return the superclass, or {@code null} if none found or previously processed + */ + @Nullable + protected final SourceClass doProcessConfigurationClass( + ConfigurationClass configClass, SourceClass sourceClass, Predicate filter) + throws IOException { + + if (configClass.getMetadata().isAnnotated(Component.class.getName())) { + // Recursively process any member (nested) classes first + processMemberClasses(configClass, sourceClass, filter); + } + // Process any @PropertySource annotations + for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable( + sourceClass.getMetadata(), PropertySources.class, + org.springframework.context.annotation.PropertySource.class)) { + if (this.environment instanceof ConfigurableEnvironment) { + processPropertySource(propertySource); + } + else { + logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() + + "]. Reason: Environment must implement ConfigurableEnvironment"); + } + } + // Process any @ComponentScan annotations + Set componentScans = AnnotationConfigUtils.attributesForRepeatable( + sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class); + if (!componentScans.isEmpty() && + !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) { + for (AnnotationAttributes componentScan : componentScans) { + // The config class is annotated with @ComponentScan -> perform the scan immediately + Set scannedBeanDefinitions = + this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName()); + // Check the set of scanned definitions for any further config classes and parse recursively if needed + for (BeanDefinitionHolder holder : scannedBeanDefinitions) { + BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition(); + if (bdCand == null) { + bdCand = holder.getBeanDefinition(); + } + if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) { + parse(bdCand.getBeanClassName(), holder.getBeanName()); + } + } + } + } + + // Process any @Import annotations + processImports(configClass, sourceClass, getImports(sourceClass), filter, true); + + // Process any @ImportResource annotations + AnnotationAttributes importResource = + AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class); + if (importResource != null) { + String[] resources = importResource.getStringArray("locations"); + Class readerClass = importResource.getClass("reader"); + for (String resource : resources) { + String resolvedResource = this.environment.resolveRequiredPlaceholders(resource); + configClass.addImportedResource(resolvedResource, readerClass); + } + } + + // Process individual @Bean methods + Set beanMethods = retrieveBeanMethodMetadata(sourceClass); + for (MethodMetadata methodMetadata : beanMethods) { + configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass)); + } + + // Process default methods on interfaces + processInterfaces(configClass, sourceClass); + + // Process superclass, if any + if (sourceClass.getMetadata().hasSuperClass()) { + String superclass = sourceClass.getMetadata().getSuperClassName(); + if (superclass != null && !superclass.startsWith("java") && + !this.knownSuperclasses.containsKey(superclass)) { + this.knownSuperclasses.put(superclass, configClass); + // Superclass found, return its annotation metadata and recurse + return sourceClass.getSuperClass(); + } + } + + // No superclass -> processing is complete + return null; + } + +--- + +## 12. Spring ASM + +bid: `2022121615335100000000000010` + +## asm + +在spring中其实很少听到asm这个关键字，asm -> Assembly，跟多是指汇编语言。 + +spring也是用到asm，而且asm包是spring-core的组成部分。spring asm 大体上跟 原生的asm 都是差不多了。 + +（参照链接)[ https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/asm/package-summary.htm ] + + + package org.springframework.asm + Spring's repackaging of ASM 9.x (with Spring-specific patches; for internal use only). + This repackaging technique avoids any potential conflicts with dependencies on ASM at the application level or from third-party libraries and frameworks. + + As this repackaging happens at the class file level, sources and javadocs are not available here. + +从package-info可以看出，repackaging，avoids any potential conflicts + +--- + +## 13. PostProcessorRegistrationDelegate + +bid: `2022121915527600000000000011` + +## PostProcessorRegistrationDelegate + +作为 Delegate 提供了 静态方法 invokeBeanFactoryPostProcessors。 + +主要是将beanFactory和beanFactoryPostProcessors做matching， +然后对beanFactoryPostProcessors做遍历调用postProcessBeanFactory(beanFactory) + +## ConfigurationClassPostProcessor + +postProcessBeanFactory(beanFactory) + +processConfigBeanDefinitions(beanFactory) + +核心的 处理方法， + +--- + +## 14. Spring Aop + +bid: `2022122715594900000000000012` + +## Aop +Aspect Oriented Programming的缩写，意为：面向切面编程。 +Spring aop 作为spring的一个模块，在springboot中是在bean的实例化中使用的。 + +AbstractAutowireCapableBeanFactory#initializeBean + + + protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) { + if (System.getSecurityManager() != null) { + AccessController.doPrivileged((PrivilegedAction) () -> { + invokeAwareMethods(beanName, bean); + return null; + }, getAccessControlContext()); + } + else { + # 实现了Aware接口会invoke对应的set方法。 + invokeAwareMethods(beanName, bean); + } + + Object wrappedBean = bean; + if (mbd == null || !mbd.isSynthetic()) { + # beanPostProcesser的before方法。 + wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); + } + + try { + # 实现了InitializingBean接口的会invoke afterPropertiesSet方法。 + invokeInitMethods(beanName, wrappedBean, mbd); + } + catch (Throwable ex) { + throw new BeanCreationException( + (mbd != null ? mbd.getResourceDescription() : null), + beanName, "Invocation of init method failed", ex); + } + if (mbd == null || !mbd.isSynthetic()) { + # beanPostProcesser的after方法。 + wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); + } + + return wrappedBean; + } + +AbstractAdvisingBeanPostProcessor#postProcessAfterInitialization + + public Object postProcessAfterInitialization(Object bean, String beanName) { + if (this.advisor == null || bean instanceof AopInfrastructureBean) { + // Ignore AOP infrastructure such as scoped proxies. + return bean; + } + + if (bean instanceof Advised) { + Advised advised = (Advised) bean; + if (!advised.isFrozen() && isEligible(AopUtils.getTargetClass(bean))) { + // Add our local Advisor to the existing proxy's Advisor chain... + if (this.beforeExistingAdvisors) { + advised.addAdvisor(0, this.advisor); + } + else { + advised.addAdvisor(this.advisor); + } + return bean; + } + } + + if (isEligible(bean, beanName)) { + ProxyFactory proxyFactory = prepareProxyFactory(bean, beanName); + if (!proxyFactory.isProxyTargetClass()) { + evaluateProxyInterfaces(bean.getClass(), proxyFactory); + } + proxyFactory.addAdvisor(this.advisor); + customizeProxyFactory(proxyFactory); + + // Use original ClassLoader if bean class not locally loaded in overriding class loader + ClassLoader classLoader = getProxyClassLoader(); + if (classLoader instanceof SmartClassLoader && classLoader != bean.getClass().getClassLoader()) { + classLoader = ((SmartClassLoader) classLoader).getOriginalClassLoader(); + } + # ProxyFactory 其实就是创建动态代理或者Cglib的 InvocationHandler调用Proxy.newProxyInstance返回代理对象 + return proxyFactory.getProxy(classLoader); + } + + // No proxy needed. + return bean; + } + +--- diff --git a/AI/mechine learning/Kubernetes 最佳实践.md b/AI/mechine learning/Kubernetes 最佳实践.md new file mode 100644 index 0000000..4e7533a --- /dev/null +++ b/AI/mechine learning/Kubernetes 最佳实践.md @@ -0,0 +1,745 @@ +# Kubernetes 最佳实践 + +> 来源：原 mongodb 集合 `t_blog` · 整理日期：2026-08-25 +> 分类 ID：`2022050319356100000000000001` · 排序：4 · 文章数：8 + +## 目录 + +1. [Mongo Replica 集群搭建](#mongo-replica-集群搭建) +2. [kubernetes nfs](#kubernetes-nfs) +3. [Mongo Replica 集群搭建-1](#mongo-replica-集群搭建-1) +4. [kubernetes](#kubernetes) +5. [kubeadm](#kubeadm) +6. [kubernetes containerd](#kubernetes-containerd) +7. [新增加work节点](#新增加work节点) +8. [kubelet](#kubelet) + +--- + +## 1. Mongo Replica 集群搭建 + +bid: `2023033021115000000000000029` + +## Replica Set 集群搭建 +本篇文章记录了基于mongodb-kubernetes-operator【Replica Set】模式集群搭建。 +[1]() +[2](https://github.com/mongodb/mongodb-kubernetes-operator) +[3](https://github.com/mongodb/mongodb-kubernetes-operator/blob/master/docs/install-upgrade.md#install-the-operator-using-kubectl) + +### 1. 事前准备 + +> kubernetes 版本： 1.23.9 +> mongodb 版本：6.0.2 +> nfs： 提前搭建好了kubernetes的nfs系统（具体搭建可以参照）。 + +### 2. github项目mongodb-kubernetes-operator + +[项目地址](https://github.com/mongodb/mongodb-kubernetes-operator) + +我们使用mongodb 官网推荐的 mongodb-kubernetes-operator 来进行集群安装。 +[document](https://github.com/mongodb/mongodb-kubernetes-operator/blob/master/docs/install-upgrade.md#install-the-operator-using-kubectl) + +我们事先把 mongodb-kubernetes-operator 项目中我们要使用的yaml文件复制到我们的工作目录 mongo, 需要的文件夹如下： + + + mongo + + config/crd/bases/ + + config/rbac/ + + config/manager/ + + config/samples/mongodb.com_v1_mongodbcommunity_cr.yaml + + deploy/clusterwide/ + + $ pwd + /usr/local/kubernetes/mongo + $ ls + config deploy + +### 3. 按照document依次进行安装 +#### 3.1 创建 mongodb 使用的namespace + + kubectl create ns kube-mongo + +#### 3.2 创建集群rbac 权限 + + # 修改 deploy/clusterwide/cluster_role_binding.yaml 中namespace 为 3.1 中我我们创建的 [kube-mongo] + kubectl apply -f deploy/clusterwide + kubectl apply -k config/rbac --namespace kube-mongo + +#### 3.3 创建 crd + + kubectl apply -f config/crd/bases/mongodbcommunity.mongodb.com_mongodbcommunity.yaml + +#### 3.4 安装operator + + kubectl create -f config/manager/manager.yaml --namespace kube-mongo + +#### 3.5 安装mongodb +修改 config/samples/mongodb.com_v1_mongodbcommunity_cr.yaml文件 +- 修改 MongoDBCommunity 资源 +我们修改 metadata.name=violin-mongodb +我们修改 spec.version= "6.0.2" +我们修改 spec.users.name[0].passwordSecretRef.name= kube-mongo-pw +- 修改 Secret 资源 +我们修改 metadata.name= kube-mongo-pw +我们修改 stringData.password= "任意随意写了吧" + +然后进行安装 + + kubectl apply -f config/samples/mongodb.com_v1_mongodbcommunity_cr.yaml --namespace kube-mongo + +#### 3.6 重新创建pvc +由于我使用的是自定义的storageclass，pvc 处于 pending状态，我们删除掉pvc + + kubectl delete pvc data-volume-violin-mongodb-0 -n kube-mongo + kubectl delete pvc logs-volume-violin-mongodb-0 -n kube-mongo + +我们创建新的pvc定义文件： + + # pvc.yaml + apiVersion: v1 + kind: PersistentVolumeClaim + metadata: + name: data-volume-violin-mongodb-0 + namespace: kube-mongo + spec: + accessModes: + - ReadWriteOnce + resources: + requests: + storage: 10Gi + storageClassName: managed-nfs-storage + --- + apiVersion: v1 + kind: PersistentVolumeClaim + metadata: + name: data-volume-violin-mongodb-1 + namespace: kube-mongo + spec: + accessModes: + - ReadWriteOnce + resources: + requests: + storage: 10Gi + storageClassName: managed-nfs-storage + --- + apiVersion: v1 + kind: PersistentVolumeClaim + metadata: + name: data-volume-violin-mongodb-2 + namespace: kube-mongo + spec: + accessModes: + - ReadWriteOnce + resources: + requests: + storage: 10Gi + storageClassName: managed-nfs-storage + --- + apiVersion: v1 + kind: PersistentVolumeClaim + metadata: + name: logs-volume-violin-mongodb-0 + namespace: kube-mongo + spec: + accessModes: + - ReadWriteOnce + resources: + requests: + storage: 1Gi + storageClassName: managed-nfs-storage + --- + apiVersion: v1 + kind: PersistentVolumeClaim + metadata: + name: logs-volume-violin-mongodb-1 + namespace: kube-mongo + spec: + accessModes: + - ReadWriteOnce + resources: + requests: + storage: 1Gi + storageClassName: managed-nfs-storage + --- + apiVersion: v1 + kind: PersistentVolumeClaim + metadata: + name: logs-volume-violin-mongodb-2 + namespace: kube-mongo + spec: + accessModes: + - ReadWriteOnce + resources: + requests: + storage: 1Gi + storageClassName: managed-nfs-storage + + 我们 创建 pvc + + kubectl apply -f pvc.yaml + # 查看pvc 是否已 + kubectl get pvc -n kube-mongo + kube-mongo data-volume-violin-mongodb-0 Bound pvc-1ac1a5fd-389c-496d-a47c-7df11d5f5a34 10Gi RWO managed-nfs-storage 41m + kube-mongo data-volume-violin-mongodb-1 Bound pvc-39008253-8702-4cc5-876a-0561850929bb 10Gi RWO managed-nfs-storage 61m + kube-mongo data-volume-violin-mongodb-2 Bound pvc-a7e867d3-b499-486a-9b39-a42ac5a00b43 10Gi RWO managed-nfs-storage 61m + kube-mongo logs-volume-violin-mongodb-0 Bound pvc-209ed46c-d558-4a09-8a2f-edfddbed610c 1Gi RWO managed-nfs-storage 41m + kube-mongo logs-volume-violin-mongodb-1 Bound pvc-664b307f-ab95-4af3-8851-17a3ecd2b57c 1Gi RWO managed-nfs-storage 61m + kube-mongo logs-volume-violin-mongodb-2 Bound pvc-a8f3a8d2-337d-4470-9ef4-5dbe18a4100a 1Gi RWO managed-nfs-storage 61m + +### 4. 关于删除资源的问题。 +我们创建operator 或者 statefuset 出错的时候，可以重新删除他们。 + +#### 4.1 删除 operator + + kubectl delete deployments.apps mongodb-kubernetes-operator -n kube-mongo + +#### 4.1 删除 statefulset + + kubectl delete statefulsets.apps violin-mongodb -n kube-mongo + +### 5. 关于 mongosh的使用 + + kubectl get secret -n -o json | jq -r '.data | with_entries(.value |= @base64d)' + + kubectl get secret violin-mongodb-admin-my-user -n kube-mongo -o json | jq -r '.data | with_entries(.value |= @base64d)' + +--- + +## 2. kubernetes nfs + +bid: `2023040608509800000000000030` + +## 1 概述 +--- +  本篇文章记录了violin-home网站NFS系统搭建过程。 +采用腾讯云的3台公网云轻量服务器（ubuntu系统） +> NFS服务需要开启 mountd,nfs,nlockmgr,portmapper,rquotad这5个服务. + +  其中 + + # 查看服务使用端口 + # nfs : 2049 + # portmapper: 111 + # mountd, nlockmgr, rquotad 是随机的 + + # 所以事先要做好端口规划, 在轻量云服务器上开放对应的端口. +```bash +rpcinfo -p +``` + + + +## 2 nfs 服务器搭建 +--- + + # install server + apt-get install nfs-kernel-server + + # enable and start server + systemctl enable nfs-server + systemctl start nfs-server + + # confirm nfs-server status + + # create storage + mkdir -p /data/nfs-volume && chmod -R 777 /data/nfs-volume + + # edit config file + cat > /etc/exports << EOF + /data/nfs-volume 49.233.4.79(rw,sync,no_root_squash) 43.138.55.43(rw,sync,no_root_squash) 43.138.73.106(rw,sync,no_root_squash) + EOF + + # view nfs port usage + rpcinfo -p + + # set port infomation for mountd、rquotad ser + # edit nfs-common status + vi /etc/default/nfs-common + STATDOPTS="--port 31000" + + # edit nfs-kernel-server status + vi /etc/default/nfs-kernel-server + RPCMOUNTDOPTS="--manage-gids -p 31001" + + # edit nlockmgr ,就算进行了这一步操作，也可能不生效。 + vi /etc/modprobe.d/options.conf + options lockd nlm_udpport=31002 nlm_tcpport=31002 + + # to add locked + vi /etc/modules + + # /etc/modules: kernel modules to load at boot time. + # + # This file contains the names of kernel modules that should be loaded + # at boot time, one per line. Lines beginning with "#" are ignored. + lockd + + vi /etc/sysctl.conf + fs.nfs.nlm_udpport=31002 + fs.nfs.nlm_tcpport=31002 + + # enable sysctl.conf + /sbin/sysctl -p + + # reload server and service + systemctl reload nfs-server + systemctl restart rpcbind.service + systemctl restart nfs.service + + # view nfs port usage again + rpcinfo -p + + # to confirm client ip + showmount -e 49.233.4.79 + # Export list for 49.233.4.79: + # /data/nfs-volume 43.138.73.106,43.138.55.43,49.233.4.79 + +## 3 nfs 客户端搭建 +--- +  下面操作需要在每台node上操作，包括master节点。 + + # install client + apt-get install nfs-common + + # create mount path for client(we use different path to server) + mkdir /opt/nfs-volume + + # mount + mount -t nfs 49.233.4.79:/data/nfs-volume /opt/nfs-volume + df -h | tail -1 + + # config auto mount for client + cat >> /etc/fstab << EOF + 49.233.4.79:/data/nfs-volume /opt/nfs-volume defaults,_netdev 0 0 + EOF + +## 4 + +--- + +## 3. Mongo Replica 集群搭建-1 + +bid: `2023040623407900000000000031` + +## Replica Set 集群搭建 +本篇文章记录了基于 helm bitnami/mongodb chat的【Replica Set】模式集群搭建。 + +[参照文档](https://github.com/bitnami/charts/tree/main/bitnami/mongodb) + +### 1. 事前准备 + +> kubernetes 版本： 1.23.9 +> mongodb 版本：6.0.2 +> nfs： 提前搭建好了kubernetes的nfs系统（具体搭建可以参照）。 +> storageclass： 提前准备好了基于nfs的storageclass。 +> helm： 已经安装了helm + +### 2. 添加bitnami repo + + helm repo add bitnami https://charts.bitnami.com/bitnami + +### 3. 查询 mongodb 相关资源 + + helm repo update + helm search repo mongodb + + NAME CHART VERSION APP VERSION DESCRIPTION + bitnami/mongodb 13.9.4 6.0.5 MongoDB(R) is a relational open source NoSQL da... + bitnami/mongodb-sharded 6.3.3 6.0.5 MongoDB(R) is an open source NoSQL database tha... + +### 4. 创建helm 配置文件 + + ## values.yaml + global: + namespaceOverride: kube-mongo + storageClass: "managed-nfs-storage" + nameOverride: violin-mongo + image: + pullPolicy: IfNotPresent + architecture: "replicaset" + replicaCount: 3 + #auth: + # rootUser: "root" + # rootPassword: "123654" + # usernames: + # - "guan" + # passwords: + # - "83201048" + # databases: + # - "violin" + resources: + requests: + cpu: "0.2" + memory: 200M + limits: + cpu: "0.3" + memory: 300M + containerPorts: + mongodb: 27017 + externalAccess: + enabled: true + service: + externalTrafficPolicy: "Cluster" + type: "ClusterIP" + persistence: + enabled: true + size: 5Gi + +### 5. 安装 mongodb + + helm install mongodb bitnami/mongodb -f values.yaml + + NAME: mongodb + LAST DEPLOYED: Fri Apr 7 11:49:07 2023 + NAMESPACE: default + STATUS: deployed + REVISION: 1 + TEST SUITE: None + NOTES: + CHART NAME: mongodb + CHART VERSION: 13.9.4 + APP VERSION: 6.0.5 + + ** Please be patient while the chart is being deployed ** + + MongoDB® can be accessed on the following DNS name(s) and ports from within your cluster: + + mongodb-violin-mongo-0.mongodb-violin-mongo-headless.kube-mongo.svc.cluster.local:27017 + mongodb-violin-mongo-1.mongodb-violin-mongo-headless.kube-mongo.svc.cluster.local:27017 + mongodb-violin-mongo-2.mongodb-violin-mongo-headless.kube-mongo.svc.cluster.local:27017 + + To get the root password run: + + export MONGODB_ROOT_PASSWORD=$(kubectl get secret --namespace kube-mongo mongodb-violin-mongo -o jsonpath="{.data.mongodb-root-password}" | base64 -d) + + To get the password for "guan" run: + + export MONGODB_PASSWORD=$(kubectl get secret --namespace kube-mongo mongodb-violin-mongo -o jsonpath="{.data.mongodb-passwords}" | base64 -d | awk -F',' '{print $1}') + + To connect to your database, create a MongoDB® client container: + + kubectl run --namespace kube-mongo mongodb-violin-mongo-client --rm --tty -i --restart='Never' --env="MONGODB_ROOT_PASSWORD=$MONGODB_ROOT_PASSWORD" --image docker.io/bitnami/mongodb:6.0.5-debian-11-r4 --command -- bash + + Then, run the following command: + mongosh admin --host "mongodb-violin-mongo-0.mongodb-violin-mongo-headless.kube-mongo.svc.cluster.local:27017,mongodb-violin-mongo-1.mongodb-violin-mongo-headless.kube-mongo.svc.cluster.local:27017,mongodb-violin-mongo-2.mongodb-violin-mongo-headless.kube-mongo.svc.cluster.local:27017" --authenticationDatabase admin -u root -p $MONGODB_ROOT_PASSWORD + + To connect to your database nodes from outside, you need to add both primary and secondary nodes hostnames/IPs to your Mongo client. To obtain them, follow the instructions below: + + +### 6. connect + + db.createUser({user: "root", pwd: "123654", roles: ["root"]}) + +--- + +## 4. kubernetes + +bid: `2023040717276500000000000032` + +## kubernetes 1.25.2 base Containerd + +### 1. deploy schedule +NAME | IP | ROLES | VERSION | OS +k8s-master | 192.168.8.30 | master | 1.25.2 | ubuntu 22.04 +k8s-node1 | 192.168.8.31 | worker | 1.25.2 | ubuntu 22.04 +k8s-node2 | 192.168.8.32 | worker | 1.25.2 | ubuntu 22.04 + +### 2. preparation + +#### 2.1 安装系统工具 +```bash +apt-get update && apt-get install -y apt-transport-https +``` +#### 2.2 安装 GPG 证书 +```bash +curl https://mirrors.aliyun.com/kubernetes/apt/doc/apt-key.gpg | apt-key add - +``` +#### 2.3 写入软件源 +```bash +cat << EOF >/etc/apt/sources.list.d/kubernetes.list +deb https://mirrors.aliyun.com/kubernetes/apt/ kubernetes-xenial main +EOF +``` +#### 2.4 vi hostname +```bash +vi /etc/hostname +vi /etc/hosts +reboot +``` +#### 2.5 selinux +```bash +sudo setenforce 0 +sudo sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config +``` +#### 2.6 禁用交换分区 +```bash +swapoff -a +sed -ri 's/.*swap.*/#&/' /etc/fstab +``` +#### 2.7 iptables +```bash +echo "1" >/proc/sys/net/bridge/bridge-nf-call-iptables +echo 1 > /proc/sys/net/ipv4/ip_forward +vi /etc/sysctl.conf +net.ipv4.ip_forward = 1 + +cat <bid: `2023041008541300000000000036` + +## 1. xxx + +22.04.1-Ubuntu + +```bash +cat << EOF >/etc/apt/sources.list.d/kubernetes.list +deb https://mirrors.aliyun.com/kubernetes/apt/kubernetes-xenial main +EOF +``` +```bash +apt-get update +apt-get install -y kubelet=1.25.2-00 kubeadm=1.25.2-00 kubectl=1.25.2-00 +``` + +```bash +sudo setenforce 0 +sudo sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config +``` + +临时关闭swap分区，当前会话生效，重启失效 +永久关闭swap分区 +```bash +swapoff -a +sed -ri 's/.*swap.*/#&/' /etc/fstab +``` +```bash +cat </proc/sys/net/bridge/bridge-nf-call-iptables +echo 1 > /proc/sys/net/ipv4/ip_forward +vi /etc/sysctl.conf +net.ipv4.ip_forward = 1 +``` + +```bash +cat > /etc/sysconfig/network-scripts/ifcfg-eth0 <> /etc/hosts +echo 192.168.8.30 k8s-master >> /etc/hosts +echo 192.168.8.31 k8s-node1 >> /etc/hosts +echo 192.168.8.32 k8s-node2 >> /etc/hosts +``` + +## about docker and cri-dockerd + +```bash +docker pull golang:1.20.2 +``` +download cri-dockerd +```bash +echo "######### https://github.com/Mirantis/cri-dockerd/releases/tag/v0.3.2 ########' +tar -zxvf cri-dockerd-0.3.2.tar.gz +``` + + +```bash +echo "######## chuangjian guazai dian ########" +mkdir /data +cd /data +mkdir go +cd go +echo "######## download cri-dockerd ########" +echo "######## https://github.com/Mirantis/cri-dockerd/releases/tag/v0.3.2 ########' +echo "######## jieya ########" +tar -zxvf cri-dockerd-0.3.2.tar.gz + +echo "######## yunxing golang container ########" +docker run -it -v /data/go:/data/go golang:1.20.2 /bin/sh +``` +enter container +```bash +cd /data/go/cri-dockerd-0.3.2 +mkdir bin +go build -o bin/cri-dockerd +``` +out container + +```bash +cd /data/go/cri-dockerd-0.3.2 +install -o root -g root -m 0755 bin/cri-dockerd /usr/local/bin/cri-dockerd +cp -a packaging/systemd/* /etc/systemd/system +sed -i -e 's,/usr/bin/cri-dockerd,/usr/local/bin/cri-dockerd,' /etc/systemd/system/cri-docker.service +systemctl daemon-reload +systemctl enable cri-docker.service +systemctl enable --now cri-docker.socket +``` + +--- + +## 6. kubernetes containerd + +bid: `2023041415557100000000000037` + +## containerd + + + + +## ctr + +## crictl + +## nerdctl + +## + +--- + +## 7. 新增加work节点 + +bid: `2023061019139700000000000038` + +## + +--- + +## 8. kubelet + +bid: `2024042923524000000000000040` + +该写点什么么... + +--- diff --git a/AI/mechine learning/machine learning.md b/AI/mechine learning/machine learning.md new file mode 100644 index 0000000..9a354bd --- /dev/null +++ b/AI/mechine learning/machine learning.md @@ -0,0 +1,487 @@ +# machine learning + +> 来源：原 mongodb 集合 `t_blog` · 整理日期：2026-08-25 +> 分类 ID：`2022102117088800000000000001` · 排序：10 · 文章数：16 + +## 目录 + +1. [第二章 模型评估与选择](#第二章-模型评估与选择) +2. [第一章 绪论](#第一章-绪论) +3. [第三章 线性模型](#第三章-线性模型) +4. [第四章 决策树](#第四章-决策树) +5. [第五章 神经网络](#第五章-神经网络) +6. [第七章 贝叶斯分类器](#第七章-贝叶斯分类器) +7. [第六章 支持向量机](#第六章-支持向量机) +8. [第八章 集成学习](#第八章-集成学习) +9. [第十章 降维与度量学习](#第十章-降维与度量学习) +10. [第九章 聚类](#第九章-聚类) +11. [第十三章 半监督学习](#第十三章-半监督学习) +12. [第十一章 特征选择与稀疏学习](#第十一章-特征选择与稀疏学习) +13. [第十二章 计算学习理论](#第十二章-计算学习理论) +14. [第十四章 概率图模型](#第十四章-概率图模型) +15. [第十五章 规则学习](#第十五章-规则学习) +16. [第十六章 强化学习](#第十六章-强化学习) + +--- + +## 1. 第二章 模型评估与选择 + +bid: `2022102117084500000000000004` + +## 2.1 经验误差与过拟合 +> 错误的样本数a占总样本数m的比例称为 错误率【error rate】E = a / m +> 精度【accuracy】 = 1 - 错误率 + +> 我们把实际预测输出与样本的真实输出之间的差异称为 误差【error】 +在训练集上 的误差 称为训练误差【training error】 +在新样本上的误差 称为 泛化误差 generalization error +> 过拟合【overfitting】，学习器把样本学的太好了，以至于把样本自身的一些特点当作所有潜在样本的都具有的一般性质，这样会导致generalization 泛化性能下降。 +> 欠拟合【underfitting】 +## 2.2 评估方法 +### 留出法【hold-out】 +直接将数据集D 划分为两个互斥的子集，S和T，其中S占大于2/3 - 4/5 左右，并且，尽量保证训练/测试的的数据划分在分布上是一致性的，避免在数据划分过程中引入额外的不必要的偏差，而对最终结果产生影响。 +使用留出法通常采用果敢此随即划分，重复实验后去均值作为评估结果。 +### 交叉验证法【cross validation】 +将数据集划分为k个大小相似的互斥子集，每个子集Di都尽可能保持数据分布的一致性，即从D中通过分层采样得到。然后用k-1个子集做训练，余下的1个子集做测试集，这样就可以获得k组训练/测试集，然后对这k次结果做均值。 +这种评估结果的稳定性和保真性极大程度上取决于k的取值。我们把这种交叉验证法称为k折交叉验证【k-fold cross validation】，k最常用的值为10，即10折交叉验证法。与hold-out method 相似，我们也是需要多次划分来取均值作为最后的评估结果。 +### 自助法【bootstrap】 +hold-out and cross validation method 使用的训练集比样本集少，必然引入了因为样本规模不同而导致的估计偏差，自助法bootstrap 是一个比较好的解决方案 +给定一个m个样本的数据集D，我们对它采样产生数据集D' ，每次随机从D中抽取一个样本，将其拷贝到D'，重复mci后，我们得到了一个m个样本的数据集D'。 +样本在m次采样中始终不被采集到的概率为（1 - 1/m）m 取极限，可得 0.368 +自助法在数据集较小时，很有用。 +## 2.3 性能度量【performance measure】 +预测任务中，给定样例集D，要评价学习器f的性能，就是要把学习器预测结果f(x)与真实标记【label】y进行比较 +回归任务最常用的性能度量是 均方误差【mean squared error】 + +> E(f;D) = 1/m ・ + +--- + +## 2. 第一章 绪论 + +bid: `2022102117089200000000000003` + +## 1.1 引言 +--- +> 学习算法，机械学习所要研究的主要内容，是关于计算机从数据中产生【模型model】的算法，模型 泛指 从数据中学得的结果。 + +--- +## 1.2 基本术语 +> 数据集【data set】 +> 样本【sample】或者 实例【instance】 +> 属性【attribute】 或者 特征【feature】 +> 属性值【attribute value】 +> 属性空间【attribute space】 +> 样本空间【sample space】 +> 学习【learning】从数据中学得模型的过程 为 学习【learning】或 训练【training】 +> 训练数据【training data】训练过程中使用的数据 为 训练数据【training data】 +> 训练样本【training sample】，训练数据中的每一个样本 成为 训练样本 【training sample】 +> 训练集 【training set】训练样本 组成的集合 为 训练集 【training set】 +> 假设【hypothesis】学得模型对应了关于数据的魔种潜在规律，即 假设【hypothesis】 +> 真相【ground-truth】这种潜在规律自身，则称为 真相【ground-truth】，学习的过程就是为了找出或者逼近真相。 +> 标记【label】，样本结果的信息，即标记【label】 +> 样例【example】，拥有了标记的实例，即为 样例【example】 + +*D* = {*x1*, *x2*, ...,*xn*} 具有n个实例的数据集 +(*x*i, *y*i)表示第i个样例。 + +> - 如果我们的预测的是离散值，此类学习的任务成为 分类【classification】 +> - 如果我们的预测是连续值，此类的学习任务成为回归【regression】 +> - 对于只涉及的两个类别的二分类【binary classification】任务，通常一个成为正类【positive class】另一个类为反类【negative class】 +> - 涉及到多个类别时，则成为多分类【multi-class classification】任务 + +> - 根据train set 中是否含有 label，学习任务分为 监督学习【supervised】 和 无监督学习【unsupervised learning】 +分类和回归是 监督学习， 而聚类是后者的代表。 + +--- +## 1.3 假设空间 +归纳【induction】和演绎【deduction】是科学推理的两大手段。 +归纳是从特殊到一般的泛化【generalization】的过程，即从具体的事实归结出一般性规律。 +演绎是从一般到特殊的特化【specialization】的过程，从基础原理推演出具体情况。 +版本空间【version space】，存在着一个与训练集一致的假设集合，我们称之为版本空间 + +--- +## 1.4 归纳偏好 +无论学习算法A多聪明，学习算法B多笨拙，他们的期望性能是相同的，这就是NFL定理，即没有免费的午餐定理 +NFL定理最重要的寓意是，如果考虑所有的潜在的问题，所有的学习算法都一样好，而算法的优劣必须建在具体的学习问题上。 +--- +### 1.5 + +--- + +## 3. 第三章 线性模型 + +bid: `2022112915369100000000000001` + +## 3.1 基本模型（linear model） +--- +给定由 $d$ 个属性描述得实例 ${\pmb{x}}$ $ = (x_{1}; x_{2};...; x_{d})$，其中$x_i$ 是 ${\pmb{x}}$ 在第 $i$ 个属性山对的取值。 +线性模型试图学得一个通过属性的 **线性组合** 来进行 预测的函数，即 +$$ +f(x) = w_1x_1 + w_2x_2 + ... + w_3x_3 + b , \tag{3.1} +$$ + +一般用向量表示，写成 +$$ +f(x) = \pmb{w}^{\pmb{T}}\pmb{x} + b, \tag{3.2} +$$ +其中${\pmb{w}}$ $ = (w_{1}; w_{2};...; w_{d})$。${\pmb{w}}$和b学得之后，模型就得以确定。 + +`※注意` +`行向量用 "," ，而列向量用 ";"` + +## 3.2 线性回归（linear regression） +给定数据集$D = \{ (x_1, y_1), (x_1, y_1), ... (x_m, y_m) \}$，其中 $\pmb{x}_i = (x_{i1}; x_{i2};...; x_{id})$，$y_i \in R$。 +线性回归 试图学习得一个线性模型，来尽可能准确的预测真实值输出标记label。 +$$ +f(x_i) = \pmb{w}^{\pmb{T}}\pmb{x_i} + b, \text{ 使得} f(x_i) \simeq y_i + \tag{3.3} +$$ + +如何确定 $w$ 和 $b$ 呢，通过2.3节的介绍过，均方误差(2.2)是回归任务中最常用的性能度量，因此我们试图让均方误差最小化。即，最小二乘法。 +即 +$$ +(w^*, b*) = arg\,min \sum_{i=1}^{m} (f(x_i) - y_i)^2 +$$ +$$ += arg\,min \sum_{i=1}^{m} (y_i - wx_i -b)^2 +$$ +$$ += arg\,min \sum_{i=1}^{m} [(y_i-b)^2 + w^2x_i^2 - 2wx_iy_i] +$$ +$$ += arg\,min \sum_{i=1}^{m} [(y_i-b)^2 + w^2x_i^2 - 2wx_iy_i] +$$ + +均方误差有非常好的几何意义，他应对了常用的欧几里得几何定理。 + +而对于多元线性回归，我们把 $\pmb{w}$ 和 $b$ 吸收入向量形式 $\hat{ \pmb{w} } = (\pmb{w};b)$， 即 $\hat{ \pmb{w} } = (w_1;w_2;...;w_d;b)$，即 d + 1 列。 +对于数据集$D$，我们将它表示为一个 $m \times (d + 1)$ 大小矩阵 $ X $，用以方便进行 $ \pmb{w}^{\pmb{T}}\pmb{x} + b$ 相乘。 +$$ +\pmb{X}=\begin{pmatrix} +x_{11} & x_{12} & \cdots & x_{1d} & 1\\ +x_{21} & x_{22} & \cdots & x_{2d} & 1\\ +\vdots & \vdots & \ddots & \vdots & 1\\ +x_{m1} & x_{m2} & \cdots & x_{md} & 1\\ +\end{pmatrix} = \begin{pmatrix} +\pmb{x}_{1}^T & 1\\ +\pmb{x}_{2}^T & 1\\ +\vdots & 1\\ +\pmb{x}_{m}^T & 1\\ +\end{pmatrix} +$$ +注意，这里的 $\pmb{x}_i$ 是列向量，转置后就是行向量了。 +这样 +$$ + \pmb{X}\hat{ \pmb{w} } = \begin{pmatrix} +x_{11} & x_{12} & \cdots & x_{1d} & 1\\ +x_{21} & x_{22} & \cdots & x_{2d} & 1\\ +\vdots & \vdots & \ddots & \vdots & 1\\ +x_{m1} & x_{m2} & \cdots & x_{md} & 1\\ +\end{pmatrix}\begin{pmatrix} +w_{1} \\ +w_{2} \\ +\vdots \\ +w_{d} \\ +b \\ +\end{pmatrix} = \begin{pmatrix} +\pmb{x}_{1}^T & 1\\ +\pmb{x}_{2}^T & 1\\ +\vdots & 1\\ +\pmb{x}_{m}^T & 1\\ +\end{pmatrix}\begin{pmatrix} +\pmb{w} \\ +b \\ +\end{pmatrix} +$$ + +再把标记也写成向量形式 $y = (y_1;y_2;...;y_m)$, 有 +$$ +\hat{\pmb{w}}^* = arg \, min (\pmb{y} - \pmb{X} \hat{\pmb{w}})^T(\pmb{y} - \pmb{X} \hat{\pmb{w}}) \tag{3.9} +$$ +令 $E_{\hat{w}} = (\pmb{y} - \pmb{X} \hat{\pmb{w}})^T(\pmb{y} - \pmb{X} \hat{\pmb{w}})$, 对 $\hat{ \pmb{w} }$ 求导得到 +$$ +\frac{\partial E_{\hat{w}}}{\partial \hat{\pmb{w}}} = 2 \, \pmb{X}^T(\pmb{X}\hat{\pmb{w}} -\pmb{y}) \tag{3.10} +$$ +令上式为0，可得 $\hat{ \pmb{w} }$ 最优解的闭式解 + +`※闭式解也被称为解析解，是通过严格的公式所求得的解，即包含分式、三角函数、指数、对数甚至无限级数等基本函数的解的形式。通过给出解的具体函数形式，从解的表达式中就可以算出任何对应值。` + +当 $\pmb{X}^T \pmb{X}$ 为满秩矩阵，可以直接令(3.10)为零即可得， +$$ +\hat{\pmb{w}}^* = (\pmb{X}^T \pmb{X})^{-1}\pmb{X}\pmb{y} +$$ +其中，$\pmb{X}^T \pmb{X})^{-1}$ 是矩阵 $\pmb{X}^T \pmb{X}$ 的逆矩阵。令$\hat{\pmb{x}}_i = (\pmb{x}_i; 1)$ 最终学得多元线性回归模型为 +$$ +f(\hat{\pmb{x}}_i) = {\hat{\pmb{x}}_i}^T(\pmb{X}^T \pmb{X})^{-1}\pmb{X}\pmb{y} +$$ + +然后现实任务中，$\pmb{X}^T \pmb{X}$ 并不是满秩矩阵，例如在许多学习任务中我们会遇到大量的参数，其数量甚至超过样例数，导致 $\pmb{X}$ 列数多于行数，此时 $\pmb{X}^T \pmb{X}$ 显然不是满秩矩阵。 +此时可解出 $\hat{ \pmb{w} }$ , 他们都能是均方误差最小化，选择哪一个解作为输出将由学习算法的归纳偏好决定，常见的作法，就是**引入正则化项**(**regularization**)。 + +线性模型虽然简单，但是却有着丰富的变化，最简单就是将标记对数化，即将输出标记的对数作为线性模型逼近的目标 +$$ +\ln y = \pmb{w}^T \pmb{x} + b \tag{3.14} +$$ +这就是 对数线性回归（log-linear regression），它实际上在试图让 $e^{\pmb{w}^T \pmb{x} + b}$逼近 $y$。(3.14) 在形式上仍是**线性回归**(linear regression), 但实质上是输入空间到输出空间的非线性的函数映射。 + +更一般的，考虑单调可微函数 $g(\cdot)$ ，令 +$$ +y = g^{-1}(\pmb{w}^T \pmb{x} + b) \tag{3.15} +$$ + +这样就得到了 **广义线性模型** (**generalized linear model**) ，其中函数 $g(\cdot)$ 称为 **联系函数** (**link function**)。 + +## 3.3 对数几率回归 + +在第一章介绍过，我们知道预测的结果为离散的，我们称为分类(classification)任务，预测的结果是连续的，我们成为回归(regression)任务。 +上一节讨论了线性模型进行回归学习，但是若要做分类任务怎么办呢？答案蕴含在(3.15)的广义线性模型中：只需要找到一个单调可微函数将分类任务的真实标记 $y$ 与线性回归模型的预测值联系起来。 + +我们先考虑二分类任务（binary classification），其输出标记 $y \in \{ 0, 1 \}$，而线性回归模型产生的预测值是 $ z = \pmb{w}^T\pmb{x} + b$ 是实值，于是我们需要通过将 $z$ 转换为 0/1 的值。 +而最理想是 **单位阶跃函数**（unit-step function） +$$ +f(n)= +\begin{cases} +0, & \text {$z < 0$} \\ +0.5, & \text {$z = 0$} \\ +1, & \text{$z > 0$} +\end{cases} \tag{3.16} +$$ + +单位阶跃函数不连续，不能作为 $g(\cdot)$ 的 反函数使用。于是我们希望，找到一个在一定程度近似于单位阶跃函数的代替函数，并希望他单调可微。**对数几率函数**（logistic function）正是这样的一个常用的替代函数。 +$$ +y = \frac{1}{1 + e^{-z}} \tag{3.17} +$$ +将 $ z = \pmb{w}^T\pmb{x} + b$ 带入3.17中得到 +$$ +y = \frac{1}{1 + e^{-(\pmb{w}^T\pmb{x} + b)}} \tag{3.18} +$$ +类似于3.14，对上式取对数，可变化为 +$$ +ln \frac{y}{1-y} = \pmb{w}^T\pmb{x} + b \tag{3.19} +$$ + +若将 $y$ 视为样本 $x$ 为正例的可能性，那么 $1-y$则是反例可能性，两者的比值 +$$ +\frac{y}{1-y} \tag{3.20} +$$ +称为 **几率**（odds），反映了 $x$ 为了正例的相对可能性，对几率取对数则得到 **对数几率**（log odds，或者logit） +$$ +\ln\frac{y}{1-y} \tag{3.21} +$$ +可以看出（3.18）实际上在用线性回归模型的预测结果去逼近真是标记的对数几率，因此，此模型称为 **对数几率模型** （logistic regression 或者 logit regression） + +下面我们来看看如何确定式(3.18)中的 $\pmb{w}$ 和 $b$.若将y视为后验概率估计 $p(y=1|x)$,则式(3.19)可重写为 +$$ +ln \frac{p(y=1|x)}{p(y=0|x)} = \pmb{w}^T\pmb{x} + b \tag{3.22} +$$ +显然有 +$$ +p(y=1|x) = \frac{e^{\pmb{w}^T\pmb{x} + b}}{1 + e^{\pmb{w}^T\pmb{x} + b}} \tag{3.23} +$$ +$$ +p(y=0|x) = \frac{1}{1 + e^{\pmb{w}^T\pmb{x} + b}} \tag{3.24} +$$ +于是，我们通过极大似然估计来估计$\pmb{w}$ 和 $b$.给定数据集$\{ (x_i, y_i) \}_{i=1}^m$,对数几率回归模型最大化"对数似然" + +$$ +\ell(\pmb{w}, b) = \sum_{i=1}^{m} p(y_i| \pmb{x_i};\pmb{w},b) \tag{3.25} +$$ + + + + +## 3.4 线性判断分析 + +## 3.5 多分类学习 + +## 3.6 类别不平衡问题 + +--- + +## 4. 第四章 决策树 + +bid: `2023011713085500000000000001` + +## 4.1 basic flow + +决策树 decision tree is a common machine learning method. + +Generally, a decision tree contains a root node，several internal nodes and several leaf nodes。 + +a leaf node corresponds to decision result. the other nodes corresponds to a attribute test. The sample set contained in each node is divided into sub-nodes according to the result of attribute test. The root node contains the samples in the set. + + +**Input** : + +learning set, the count of sample set is m +$$ + D = {(x_1, y_1), (x_2, y_2), ..., (x_m, y_m)} +$$ +attribute set, the count of attribute set is d +$$ +A = {a_1, a_2, ..., a_d} +$$ +**Process**: +function treeGenerate(D, A) +1. generate node; +2. if the kinds(y) in the node are same, we mark this node leaf node and return +3. if A is empty or the value of D is same in A. we mark this node leaf node and return +4. to choose the best divided attribute $a_*$ +5. for the value of $a_*$: +6. to generate a node + + +## 4.2 how to choose a divided method + +### 4.2.1 information gain (信息增益) + + 信息熵 information entropy + +$$ +Ent(D) = -\sum ^{|y|}_{k = 1} p_{k}log2p_{k} +$$ +means that + + 信息增益 imformation gain + +### 4.2.2 gain ratio（增益率） + +信息增益 对可选数值数目较多的属性有所偏好， +to reduce the possible adverse effect of this preference, the famous dicision tree algorithm **C4.5** does not use information gain directly, but use information gain ratio to select the optimal divided attributes. + +represent it with: + +$$ +Gain\_ratio(D, a) = \frac{Gain(D, a)}{IV(a)} +$$ + +$$ +IV(a) = - \sum^{V}_{v = 1}\frac{D^v}{D}\log{2}\frac{D^v}{D} +$$ + +需要注意的是增益率对可选择的属性值较少的具有偏好，所以C4.5并不是直接选择增益率最大的，而是先从划分属性中找到信息增益高出平均水平的，再从其中选择增益率最高的。 + +### 4.2.3 基尼指数 + + 略 +## 4.3 减枝处理 + +剪枝是决策树学习算法对付过耦合的主要手段。 + +决策树的基本剪枝策略有预剪枝和后剪枝。 + +预剪枝是指在决策树生成过程中，对每个节点划分前进行估计，若当前节点的划分不能带来决策树泛化性能提升，则停止划分并将当前节点标记为叶节点； + +后剪枝则是先从训练集生成一颗完整的决策树，然后自下而上地对非叶子节点考察，若将该节点对应的子树替换为叶子节点能带来决策树泛化性能提升，则将该子树替换成叶节点。 + +### 4.3.1 预剪枝 + + work flow: + 1. caculate + + +### 4.3.2 后剪枝 + + +## 4.4 连续与缺失值 + +## 4.5 多变量决策树 + +--- + +## 5. 第五章 神经网络 + +bid: `2023011719438400000000000002` + +该写点什么么... + +--- + +## 6. 第七章 贝叶斯分类器 + +bid: `2023011719441200000000000004` + +该写点什么么... + +--- + +## 7. 第六章 支持向量机 + +bid: `2023011719441300000000000003` + +该写点什么么... + +--- + +## 8. 第八章 集成学习 + +bid: `2023011719447400000000000005` + +该写点什么么... + +--- + +## 9. 第十章 降维与度量学习 + +bid: `2023011719451200000000000007` + +该写点什么么... + +--- + +## 10. 第九章 聚类 + +bid: `2023011719454000000000000006` + +该写点什么么... + +--- + +## 11. 第十三章 半监督学习 + +bid: `2023011719460100000000000010` + +该写点什么么... + +--- + +## 12. 第十一章 特征选择与稀疏学习 + +bid: `2023011719464700000000000008` + +该写点什么么... + +--- + +## 13. 第十二章 计算学习理论 + +bid: `2023011719468000000000000009` + +该写点什么么... + +--- + +## 14. 第十四章 概率图模型 + +bid: `2023011719469800000000000011` + +该写点什么么... + +--- + +## 15. 第十五章 规则学习 + +bid: `2023011719472500000000000012` + +该写点什么么... + +--- + +## 16. 第十六章 强化学习 + +bid: `2023011719475600000000000013` + +该写点什么么... + +--- diff --git a/AI/mechine learning/probability and statistics.md b/AI/mechine learning/probability and statistics.md new file mode 100644 index 0000000..899a9b8 --- /dev/null +++ b/AI/mechine learning/probability and statistics.md @@ -0,0 +1,839 @@ +# probability and statistics + +> 来源：原 mongodb 集合 `t_blog` · 整理日期：2026-08-25 +> 分类 ID：`2022102117130200000000000002` · 排序：11 · 文章数：6 + +## 目录 + +1. [1. 随机事件](#1-随机事件) +2. [3. 随机变量的重要数字特征](#3-随机变量的重要数字特征) +3. [2. 随机变量以及其分布率](#2-随机变量以及其分布率) +4. [4. 参数估计](#4-参数估计) +5. [5. 置信区间](#5-置信区间) +6. [10. 线性回归分析和方差分析](#10-线性回归分析和方差分析) + +--- + +## 1. 1. 随机事件 + +bid: `2022102117130400000000000005` + +## Proba + +[视频课程](https://www.bilibili.com/video/BV1D741147G5?p=9&spm_id_from=pageDriver) + +### 1.2 随机试验 +### 1.3 样本空间 +### 1.4 随机事件 +### 1.5 事件关系和运算 +### 1.6 频率和概率 +### 1.7 古典概型 +### 1.8 超几何概型 +### 1.9 几何概型 +--- +## 1.10 条件概率 + +随机事件对应的sample space 为 S +随机事件A 对应的样本空间是 CA +随机事件B 对应的样本空间是 CB +那么在已知随机事件A 已经发生的情况下，随机事件B的发生概率，记为 P(B|A) +> $$ +P(B|A) = \frac{P(AB)}{P(A)} +$$ +※注意、P(AB)与P(B|A)的意思是不同的，P(AB)是在样本空间S的下A和B同时发生的概率，P(B|A)是在已知A已经发生情况下的，B发生的概率，此时样本空间已经从S缩减至A。 + +### 条件概率 性质 +P(A) > 0 时， +(1) $P(B|A) \geq{0}$ +(2) $P(S|A) = 1, P(\phi|A) = 0 $ +(3) $P(B \cup C | A) = P(B|A) + P(C|A) - P(BC|A) $ +(4) $P(B - C | A) = P(B|A) - P(BC|A) $ +(5) $P(\overline{B} | A) = 1 - P(B|A) $ + +--- +## 1.11 乘法公式 +$$ +P(B|A) = \frac{P(AB)}{P(A)} +$$ +由条件概率公式可知 +$$ +P(AB) = P(A)P(B|A) +$$ +$$ +P(ABC) = P(A)P(B|A)P(C|AB) +$$ + +乘法公式 多个事件的积事件，前一个事件发生对后一个事件有影响的情况下 +将文字描述转化为 符号 +--- +## 1.12 全概率公式 与 贝叶斯公式 + +对于事件A，很复杂，无法单独求出概率，但是已知两两互不相容的事件B1，B2，B3， +$S = B_1 + B_2 + B_3 $ +对于任意事件A，$ A\subset{S} $： +$$ +由 P(A) = P(A)P(S) 即，P(A) = P(A)(P(B_1) + P(B_2) + P(B_3) ) +$$ +$$ + P(A) = P(A)P(B_1) + P(A)P(B_2) + P(A)P(B_3) +$$ +$$ + P(A) = P(B_1)P(A|B_1) + P(B_2)P(A|B_2) + P(B_3)P(A|B_3) +$$ + +> 划分 ，对于事件B1 到 Bn，两两互不相容，且合集为 S，则称 B1到Bn是样本空间的一个划分，则对于每次的随机试验，事件B1到Bn有且只有一个发生。 +样本空间的划分通常是不唯一的。 + +### 全概率公式 +$$ + P(A) = P(B_1)P(A|B_1) + P(B_2)P(A|B_2) + ... + P(B_n)P(A|B_n) +$$ +$$ + 即，P(A) = \sum_{i=1}^{n} P(B_i)P(A|B_i) +$$ + +### 贝叶斯公式 +已知A已经发生，求Bi发生的概率 +$$ + 即，P(B_i) = P(B_i|A) = \frac{P(AB_i)}{P(A)} = \frac{P(B_i)P(A|B_i)}{\sum_{i=1}^{n} P(B_i)P(A|B_i)} +$$ + +可以看出，贝叶斯 是由结果推出原因的公式 + +### 先验概率与后验概率 + +单纯的概率$P(B_i)$我们叫做**先验概率**，指的是在没有别的前提信息情况下的概率值，这个值一般需要借助我们的经验估计得到。 +而条件概率$P(B_i|A)$，我们把他叫做是**后验概率**，他代表了在获得了信息 之后出现的概率，可以说后验概率是先验概率在获取了新信息之后的一种修正。 + +--- +## 1.12 独立性 + +设 事件A 和事件B ，若满足 P(AB) = P(A)P(B) +我们则称这两个事件A和B是相互独立的。 +互不相容 和 独立性是 不能同时存在的 + +两个事件独立则有$ P(AB) = P(A)P(B) > 0 $ +两个事件互不相容则有$ P(AB) = P(A)P(B) = \phi $ +不可能事件 和 任一事件 相互独立 +必然事件 和 任意事件 也 相互独立 + +--- + +## 2. 3. 随机变量的重要数字特征 + +bid: `2022102117153700000000000007` + +## 1.1 样本均值 +>设 $X_1,X_2,\cdots,X_n$ 为总体 $X$ 的样本，样本容量为 $n$，则样本均值为 +$$ +\bar{X}=\frac{1}{n}\sum_{i=1}^{n}X_i +$$ + +用样本均值来估计总体的期望$\mu$，$\bar{X}$是围绕$\mu$左右波动的，即多次采样计算出来的统计量 $\bar{X}$ 有的落在 $\mu$ 左边，有的落在 $\mu$ 右边， +由于 $\bar{X}$ 落在 $\mu$ 左右两侧的情况是均匀的，即 $E(\bar{X})=\mu$，所以 $\bar{X}$ 就是 $\mu$ 的无偏估计。 +样本均值能够保持比较好的无偏性是因为它的计算过程本质还是一个线性过程，这个就是无偏。 + +## 1.2 加权平均 +## 1.3 数学期望 + +>离散型随机变量X的分布率 +$$ +P\{X=x_k\}=p_k, \quad k=1,2,3... +$$ +级数 +$$ +\sum_{k=1}^{\infty}x_kp_k +$$ +绝对收敛，则称级数为随机变量X的数学期望，记为$E(X)$,即 +$$ +E(x) = \sum_{k=1}^{\infty}x_kp_k +$$ +注意* 数学期望可能不存在。 +**计算** 核心是确定分布率，数学期望，反映了随机变量X的取值的平均水平 + + +>连续性随机变量X的分布率 +概率密度函数$f(x)$ +若积分 +$$ +\int_{-\infty}^{+\infty} x \cdot p(x)dx +$$ +绝对收敛，则称积分值$\int_{-\infty}^{+\infty} x \cdot p(x)dx$为随机变量X的数学期望，记为$E(X)$ +即 +$$ +E(x)=\int_{-\infty}^{+\infty} x \cdot p(x)dx +$$ +注意绝对收敛，是取|x| + +> 数学期望的性质 +(1) 设C为常数，则$E(C)=C$ +(2) 设$X,Y$是相互独立的随机变量，则$E(XY)=E(X) \cdot E(Y)$ + +## 1.4 总体方差(variance) +>设$X$是随机变量,$E\{[X-E(X)]^2 \}$存在，则称$E\{[X-E(X)]^2 \}$为随机变量X的方差，记为$D(X)$或$Var(X)$即 +$$ +D(X)=Var(X)=E\{[X-E(X)]^2 \} +$$ + +引入 +$$ +\sigma(X)=\sqrt{D(X)} +$$ +为均方差，或者标准差。 +注意： +$D(X)$表示随机变量的取值和他的数学期望的偏离程度。 +$D(X)$较小，则随机变量X大多分布在数学期望附近。 +$D(X)$较大，则随机变量X取值分散。 +$D(X)$刻画了随机变量X的分散程度的量度。 + +> 离散型随机变量的方差 +$$ +E\{[X-E(X)]^2 \}=D(X)=Var(X)=\sigma^{2}=\sum_{k=1}^{\infty}[x_k -\mu]^{2} \cdot P_k +$$ + +> 连续型随机变量的方差 +$$ +E\{[X-E(X)]^2 \}=D(X)=Var(X)=\sigma^{2}=\int_{-\infty}^{+\infty} [x -\mu]^{2} \cdot f(x)dx +$$ + +> 性质 +由 +$$ +E\{[x-E(X)]^2 \} = \int_{-\infty}^{+\infty}[x-E(X)]^2 \cdot f(x)dx +$$ +$$ += \int_{-\infty}^{+\infty}x^2 \cdot f(x)dx -2xE(x)\int_{-\infty}^{+\infty}f(x)dx + E^{2}(X)\int_{-\infty}^{+\infty}f(x)dx +$$ +$$ +=E(x^2)-2E^{2}(x) + E^{2}(x) = E(x^2)-E^{2}(x) +$$ +$$ +\sigma^{2}=E(x^2)-\mu^{2} +$$ +## 1.5 样本方差 +> 样本方差和总体方差是不一样的，样本方差如下： +$$ +S^{2}=\frac{1}{n-1} \sum_{i=1}^{n}(X_i - \bar{X})^{2} +$$ + +下面我们从推导一下，样本方差为什么是$\frac{1}{n-1}$ +由方差的基本定义可知道，(样本值 - 均值) 的 平方后的 均值可知，暂时认为 +$$ +S^2 = \frac{1}{n}\sum_{k=1}^{n}[X_i - \bar{X}]^2 +$$ +那么该方差的数学期望为 +$$ +E(S^2) = E[\frac{1}{n}\sum_{k=1}^{n}[X_i - \bar{X}]^2] +$$ +$$ +E(S^2) = E[\frac{1}{n}\sum_{k=1}^{n}[(X_i - \mu) - (\bar{X} - \mu)]^2 ] +$$ +$$ +E(S^2) = E [\frac{1}{n}\sum_{k=1}^{n}[(X_i - \mu)^2 - (X_i - \mu)(\bar{X} - \mu) + (\bar{X} - \mu)^2] ] +$$ +$$ +E(S^2) = E [\frac{1}{n}\sum_{k=1}^{n}(X_i - \mu)^2 - \frac{2}{n}\sum_{k=1}^{n}(X_i - \mu)(\bar{X} - \mu) + \frac{1}{n}\sum_{k=1}^{n}(\bar{X} - \mu)^2 ] +$$ +$$ +E(S^2) = E [\frac{1}{n}\sum_{k=1}^{n}(X_i - \mu)^2 - \frac{2}{n}(\bar{X} - \mu)\sum_{k=1}^{n}(X_i - \mu) + \frac{1}{n}\sum_{k=1}^{n}(\bar{X} - \mu)^2 ] +$$ +$$ +E(S^2) = E [\frac{1}{n}\sum_{k=1}^{n}(X_i - \mu)^2 - \frac{2}{n}(\bar{X} - \mu)n(\bar{X} - \mu) + \frac{1}{n}(\bar{X} - \mu)^2 ] +$$ +$$ +E(S^2) = E [\frac{1}{n}\sum_{k=1}^{n}(X_i - \mu)^2 - \frac{1}{n}(\bar{X} - \mu)^2 ] +$$ +$$ +E(S^2) = E [\frac{1}{n}(\sum_{k=1}^{n}(X_i - \mu)^2 - (\bar{X} - \mu)^2) ] +$$ + +$$ +E(S^2) = E [\frac{1}{n}\sum_{k=1}^{n}((X_i - \mu)^2 - (\bar{X} - \mu)^2) ] +$$ + +$$ +E(S^2) = E [\frac{1}{n}\sum_{k=1}^{n}(X_i - \mu)^2] - \frac{1}{n}E[(\bar{X} - \mu)^2 ] +$$ + +$$ +E(S^2) = \sigma^2 - \frac{1}{n}E[(\bar{X}^{2} -2\bar{X}\mu + \mu^2) ] +$$ + +$$ +E(S^2) = \sigma^2 - \frac{1}{n}(E(\bar{X}^{2}) -2\mu E(\bar{X}) + E(\mu^2)) +$$ + +$$ +E(S^2) = \sigma^2 - \frac{1}{n}(E(\bar{X}^{2}) - E(\mu^2)) +$$ + +$$ +E(S^2) = \sigma^2 - \frac{1}{n}\sigma^2 = \frac{n-1}{n}\sigma^2 \neq \sigma^2 +$$ +我们看出，$E(S^2)$和总体方差是不相等的，即是有偏向的，为了修正这个问题， +我们需要重新估计得到 +$$ +S^2 = \frac{1}{n-1}\sum_{k=1}^{n}[X_i - \bar{X}]^2 +$$ + +## 1.6 均方误差（mean-square error, MSE） +均方误差是 反映估计量与被估计量之间差异程度的一种度量。 +>一般地，在样本量一定时，评价一个点估计的好坏标准使用的指标 是点估计与参数真值 的距离的函数，最常用的函数是距离的平方. +由于估计量 具有随机性，可以对该函数求期望，这就是下式给出的均方误差： +$$ +E(X_i) = \frac{1}{n} \sum_{i=1}^{n} (f(x_i) -y_i)^2 +$$其中 $f(x_i)$ 为预测值，$y_i$为真值。 + +## 1.6 相关系数 +## 1.7 矩阵 + +## 7.2 矩 + +**矩** + +1. $k$阶矩($k$阶原点矩) + +设$X$是随机变量，若 +$$ +E(X^k), \quad k=1,2,3... +$$ +存在，称它为$X$的$k$阶**原点矩**，简称$k$阶矩。 + +注意：k=1,是1阶矩，$E(X)$，1阶矩是数学期望 +k=2，是2阶矩，$E(x^2)$的数学期望。 + +$$ +E(X^k)=\int_{-\infty}^{+\infty}x^{k}f(x)dx, \quad k=1,2,3... +$$ + +2. $k$阶中心矩 + +设$X$是随机变量，若 +$$ +E\{[X-E(X)]^k\}, \quad k=2,3... +$$ +存在，称它为$X$的$k$阶**中心矩**。 +注意：k=2的时候，2阶中心距就是方差。 + +$$ +E\{[X-E(X)]^k\}=\int_{-\infty}^{+\infty}[X-E(X)]^kf(x)dx, \quad k=2,3... +$$ + +3. $k+l$阶混合矩 + +设$(X+Y)$是随机变量，若 +$$ +E(X^{k}Y^{l}), \quad k,l=2,3... +$$ +存在，称它为$X,Y$的$k+l$阶**混合矩**。 + +注意：k=l=1的时候，E(XY)的数学期望。 + +4. $k+l$阶混合中心矩 + +设$(X+Y)$是随机变量，若 +$$ +E([X-E(X)]^{k}[Y-E(Y)]^{l}), \quad k,l=1,2,3... +$$ +存在，称它为$X,Y$的$k+l$阶**混合中心矩**。 + +注意：当$k=l=1$的时候，$k+l=2$,即2阶混合中心距，协方差$Cov(X,Y)$是$X$和$Y$的2阶混合中心距。 + +**协方差矩阵** + +对n维随机变量使用协方差矩阵研究。 + +1. 2维随机变量的协方差矩阵 +设2维随机变量(X,Y)有四个2阶中心距，分别为 +$c_{11}=E\{[X-E(X)]^{2}\}$ +$c_{12}=E\{[X-E(X)][Y-E(Y)]\}$ +$c_{21}=E\{[Y-E(Y)][X-E(X)]\}$ +$c_{22}=E\{[Y-E(Y)]^{2}\}$ +将他们排成矩阵的形式 +$$ +\begin{pmatrix} +c_{11} & c_{12} \\ +c_{21} & c_{22} \\ +\end{pmatrix} \tag{1} +$$ +这个矩阵就成为随机变量(X,Y)的协方差矩阵。是一个对称矩阵 + +2. n维随机变量$(X_1,X2,...X_n)$的协方差矩阵 +$c_{ij}=E[X_i-E[X_i]]E[X_j-E(X_j)]$的协方差都存在。 +则称矩阵 +$$ +\begin{pmatrix} +c_{11} & c_{12} & ... & c_{1n}\\ +c_{21} & c_{22} & ... & c_{2n}\\ +\vdots & \vdots & \ & \vdots\\ +c_{n1} & c_{n2} & ... & c_{nn}\\ +\end{pmatrix} \tag{1} +$$ +称为n维随机变量$(X_1,X2,...X_n)$的协方差矩阵 + +在数理统计中，往往并不知道n维随机变量的概率分布，或者太复杂，以至于无法处理，因此在实际应用中协方差矩阵就很重要了。 + +--- + +## 3. 2. 随机变量以及其分布率 + +bid: `2022102117154100000000000006` + +## 第二部分 随机变量 +--- + +用随机变量 来表示 随机事件 是 probability 中最要用的应用。 +随机变量定义： +设随机实验的样本空间 +$ S = \{e \},$ $X = X(e) $是定义在样本空间S上的单值函数，称$ X = X(e)$为随机变量。 +约定，用 X，Y，Z， W 来表示随机变量，用小写的x，y，z，w 实数 +X是指随机事件的描述。 + +离散型数学变量，我们用分布律来描述。 +分布律： +设 离散型随机变量X的所有可能取值为$ x_k(k=1,2,3...) $ +事件{$X=x_k$}的概率P{$X=x_k$} = $p_k$,为离散型随机变量的分布率。 + +## 随机变量的分布函数 +--- +适合离散型和非离散型的各种应用 +**定义** +设$X$是一个随机变量，$x$是任意实数，函数$f(x)=P{X≦x}, -\infty≦x≦+\infty$ +称为X的分布函数 +定义域： $-\infty≦x≦+\infty$ +值域 ：$0≦F(x)≦1$ +性质： +1，单调不减 +2，有界性 +3，右连续的 +离散型的概率分布都是左闭右开的。 + +## 离散型随机变量的分布率 +--- +### 2.1 0-1分布 +### 2.2 二项分布 +特性：重复，独立 +以X表示在n重伯努利实验中事件A发生的次数$P(A) = p, 0< p < 1$ +定义：若X 的分布律为 +$ P\{X=k\} = C_n^kP^k(1-P)^{n-k}$ +则称随机变量X服从参数为n，P的二项分布，记为$ X ~ b(n,P)$ +n发生次数，P为每次发生的规律。 +### 2.3 泊松分布 +大量次数，每次发生的概率很小的情况下，可以用泊松分布计算， +此时λ = np +$$ +P\{X=k\} =\frac{λ^k-e^{-λ}}{k!} +$$ +### 2.4 几何分布 +重复独立的随机试验中，试验次数事先无法确定，每一次成功的概率为p，将实验进行至成功为止，以X表示实验进行的次数，则X的分布律为 +$$ +P\{X=k\} = (1-p)^{k-1}p +$$ +像这样的随机分布为几何分布 +### 2.5 超几何分布 +从大N件产品中（包含M件次品）取出n件产品，以X表示取到的次品数，则X的分布律为 +$$ +P\{X=k\} = \frac{C_M^k C_{N-M}^{n-k}}{C_N^n} +$$ +则称随机变量X服从参数为(N，M，n)的超几何分布。 + +## 连续性随机变量以及其概率密度 +--- +> 连续性随机变量 定义 +若对于随机变量$X$的分布函数$F(X)$，存在非负可积函数$f(x)$，使对于任意实数$x$有 +$$ +F(x)=\int_{-\infty}^{x}f(x)dx +$$ +则称$X$为连续性随机变量，$f(x)$为$X$概率密度函数，简称概率密度。 + +### 2.6 均匀分布（uniform distribution） +> 定义 +若随机变量的X的概率密度为 +$$ +f(x)= \begin{cases} +\frac{1}{b-a}x, \quad a 定义 +若随机变量的X的概率密度为 +$$ +f(x)=\frac{1}{\sqrt{2 \pi} \sigma} \cdot e^{- \frac{(x-\mu)^2}{2 \sigma^2}} +$$ +其中$\mu, \sigma$为常数，且 $\sigma > 0$，则称$X$服从参数$\mu, \sigma$的正态分布，记为 $X \sim N(\mu,\sigma)$，其分布函数为 +$$ +F(x)=\int_{-\infty}^{x} \frac{1}{\sqrt{2 \pi} \sigma} \cdot e^{- \frac{(x-\mu)^2}{2 \sigma^2}} dx +$$ + + +> 已知概率积分(Gaussian integral)或者 高斯积分 +$$ +\int_{-\infty}^{+\infty} e^{-x^2}dx = \sqrt{\pi} +$$ +则有 +$$ +F(x)=\int_{-\infty}^{x} \frac{1}{\sqrt{2 \pi} \sigma} \cdot e^{- \frac{(x-\mu)^2}{2 \sigma^2}} dx +$$ +设 +$$ +t = \frac{(x-\mu)}{\sqrt{2}\sigma} => dx = \sqrt{2}\sigma dt +$$ +则 +$$ +F(x)=\int_{-\infty}^{x} \frac{1}{\sqrt{2 \pi} \sigma} \cdot e^{-t^2} \cdot \sqrt{2}\sigma dt +$$ +$$ +F(x)=\frac{1}{\sqrt{\pi}}\int_{-\infty}^{x} e^{-t^2} dt = 1 +$$ + +### 概率密度函数的图形 + +- 对称性 +$f(x)$关于$x=\mu$对称 +$P\{ \mu-h 定义 +若随机变量的X的概率密度为 +$$ +f(x)= \begin{cases} +\frac{1}{\theta}e^{x/\theta}, \quad x>0 \\ +0 \quad, \text{others}\\ +\end{cases} \tag{3} +$$ +其中$\theta >0 $为常数，记为$X \sim exp(\theta)$则称$X$服从参数为$\theta$的指数分布。 +其概率分布为 +$$ +F(x)=\begin{cases} +1 - e^{x/\theta}, \quad x>0 \\ +0 \quad, \text{others}\\ +\end{cases} \tag{4} +$$ + + +### 2.9 边缘分布 + +### 2.10 条件分布 + +## 二维随机变量 +--- +### 3.1 随机变量的相互独立性 +已知 +$X,Y$的联合分布函数$F(x,y)$，边缘分布函数$F_X(x),F_Y(y)$ +$F(X,Y)=P\{X\leq x,Y \leq y \} =P\{ X \leq x \} \cdot P\{ Y \leq y \}$ +$= F_X(x) \cdot F_Y(y)$ + +--- + +## 4. 4. 参数估计 + +bid: `2022102117160500000000000008` + +## 第七章 参数估计 +--- + +- 在进入数理统计学习之前，我们明确以下概念问题，有助于我们学习这些知识到底来干什么。 + +- probability and statistics are two faces of a coin。 +- from 【All of Statistics】 book + +>The basic problem that we study in probability is: +Given a data generating process, what are the properities of the outcomes? + +>The basic problem of statistical inference is the inverse of probability: +Given the outcomes, what can we say about the process that generated the data? + +- 概率论，给出概率分布，算出概率，即知总体，估算样本 +- 数理统计，给出样本数据，推算出概率分布（参数），即知道样本估算总体。 + +about statistics, we will learn estimation。 +点估计，区间估计，最大似然估计（maximum likelihood estimation） + +## 7.1 点估计 +点估计问题 + +> 设总体$X$的分布函数（概率密度，分布率）的形式已知，但他的一个或者多个参数未知，借助于总体$X$的一个样本来估计总体未知参数的值的问题，称为参数的点估计问题 + +点估计问题的提法 + +已知：总体$X$的分布函数的$F(x;\theta)$的形式 + +未知：$\theta$待估参数，此处的$\theta$可以理解为向量，$\theta=(\theta_1,\theta_2,\theta_3)$ + +利用：$X_1,X_2,...,X_n$是$X$的一个样本，$x_1,x_2,...,x_n$是样本值 + +点估计问题： + +构造一个适当的统计量$\hat{\theta}(X_1,X_2,...,X_n)$ + +用它的观察值$\hat{\theta}(x_1,x_2,...,x_n)$ +作为位置$\theta$的近似值。 + +### 7.1.1 矩估计 + +### 知识点 +总体$X$ +- X的k阶原点矩 $E(X^k) \quad k=1,2,3..,n$ +总体1阶矩，$E(X)$ +总体2阶矩，$E(X^{2})$ + +样本$X_1,X_2,..,X_n$ +- 样本的k阶原点矩 $A_{k}=\frac{1}{n} \sum_{i=1}^{n}X_{i}^{k} \quad k=1,2,3..,n$ +样本1阶矩，$\bar{X}$ +样本2阶矩，$A_{2}=\frac{1}{n} \sum_{i=1}^{n}X_{i}^{2} $ + +### 理论基础 +样本的k阶矩是依概率而收敛于总体的k阶矩的。 +当样本足够大的时候，即n取无穷的时候$A_k$就近似于$E(X^{k})$ + +### 矩估计的求解步骤 +设总体X的分布中有m个未知参数$\theta_{1},\theta_{2},\theta_{3},...,\theta_{m}$ +1. 求总体的各阶矩 +2. 令样本的各阶矩等于总体的各阶矩，得到m个参数的方程，然后求解方程式 + +### 7.1.2 最大似然估计法 +最大似然估计(maximum likelihood estimation, MLE)一种重要而普遍的求估计量的方法。 + +一，离散型 +>设总体X为离散型，分布率已知，但是分布中有m个位置参数$\theta_{1},\theta_{2},...,\theta_{m}$，$X_{1},X_{2},...,X_{n}$是总体X的一个样本，$x_{1},x_{2},...,x_{n}$是对应的样本值。 +已知$X_{1},X_{2},...,X_{n}$取到观察值$x_{1},x_{2},...,x_{n}$的概率， +即事件$P\{ X_{1}=x_{1},X_{2}=x_{2},...,X_{n}=x_{n} \}$发生的概率为 +$$ +L(x_1,x_2,...,x_n;\theta_{1},\theta_{2},...,\theta_{m})=\prod_{i=1}^{n}P\{ X=x_1 \} \quad (7.3) +$$ +这一概率随$\theta_{1},\theta_{2},...,\theta_{m}$的取值而变化，他是m个未知参数$\theta_{1},\theta_{2},...,\theta_{m}$的函数，称为样本的似然函数，需要注意的是$x_{1},x_{2},...,x_{n}$是已知的样本值。 + +最大似然估计的思想是： +已经取到样本值$x_{1},x_{2},...,x_{n}$，这就说明，这一样本值发生的概率$L(x_1,x_2,...,x_n;\theta_{1},\theta_{2},...,\theta_{m})$比较大。 +因此，可以固定样本观察值$x_{1},x_{2},...,x_{n}$，挑选使似然函数$L(x_1,x_2,...,x_n;\theta_{1},\theta_{2},...,\theta_{m})$达到最大值的 +$$ +\hat{\theta}_{i}(x_1,x_2,...,x_n) \quad i=1,2,...,m +$$ +用这种思想求出的参数值 + +二，连续型 + +>设总体X为连续型，$X_{1},X_{2},...,X_{n}$是总体X的一个样本，$x_{1},x_{2},...,x_{n}$是对应的样本值，则$X_{1},X_{2},...,X_{n}$的联合概率密度$(X_{1},X_{2},...,X_{n})$的$f(x_{1},x_{2},...,x_{n})=f_{X_1}(x_1) \cdot f_{X_2}(x_2) \cdots f_{X_n}(x_n)$ +$$ +L(x_1,x_2,...,x_n;\theta_{1},\theta_{2},...,\theta_{m})=\prod_{i=1}^{n}f(x_i;\theta_{1},\theta_{2},...,\theta_{m}) \quad (7.4) +$$ + +随机点$X_{1},X_{2},...,X_{n}$落在点$(x_{1},x_{2},...,x_{n})$的邻域(边长分别为$dx_1,dx_2,...,dx_n, $的n维立方体)内近似概率为 +$$ +\prod_{i=1}^{n}f(x_i;\theta_{1},\theta_{2},...,\theta_{m})dx_i \quad (7.5) +$$ +$$ +\prod_{i=1}^{n}f(x_i;\theta_{1},\theta_{2},...,\theta_{m}) \cdot \prod_{i=1}^{n}dx_i \quad (7.6) +$$ +这一概率随$\theta_{1},\theta_{2},...,\theta_{m}$的取值而变化，最大似然估计的思想是取$\theta_{1},\theta_{2},...,\theta_{m}$的估计值，使上述概率取得最大值，注意 +$$ +\prod_{i=1}^{n}dx_i \quad (7.7) +$$ +不随$\theta_{1},\theta_{2},...,\theta_{m}$的改变而改变，故而只需考虑函数 +$$ +\prod_{i=1}^{n}f(x_i;\theta_{1},\theta_{2},...,\theta_{m}) +$$ +的最大值即可，我们称n维随机变量的联合概率密度函数（7.4）为样本的似然函数。 + +解题步骤 +（1）写出 似然函数 +（2）对似然函数左右两边取对数，由乘积变成对数和。 +（3）对各个参数求偏导数，形成方程组。 +（4）求解方程组，求出参数。 + +## 7.2 估计量评价标准 + +通过点估计，矩估计和最大似然估计求出的估计量是各不相同的，如何评价估计量的好坏就是估计量的评价标准。 + +- 无偏性 +> 定义 +设总体 $\xi$ 的概率分布函数为 $F(x; \theta)$，其中 $x$ 为变元，$ \theta∈ \Theta$为未知参数，$\Theta$称为参数空间。 +$(\xi_1,\xi_2, \cdots ,\xi_{n})$为取自总体$\xi$的随机样本，若$(\xi_1,\xi_2, \cdots ,\xi_{n})$是参数$\theta$的一个估计量，且对一切 $ \theta∈ \Theta$，关系式 $E_{\theta}=E[(\xi_1,\xi_2, \cdots ,\xi_{n})]$，其中$E_{\theta}=E[(\xi_1,\xi_2, \cdots ,\xi_{n})]$表示数学期望，则称$(\xi_1,\xi_2, \cdots ,\xi_{n})$为参数$\theta$的无偏估计，具有无偏性。 + +- 有效性 +- 相合性 +- + +--- + +## 5. 5. 置信区间 + +bid: `2022102117166600000000000009` + +## 5.1 置信区间 +--- +> 定义 设总体$X$的分布函数$F(x;\theta)$,含有一个位置参数$\theta, \theta \in \Theta, \Theta$是 $\theta$的可能的取值范围。 +对于给定值 $ 0<\alpha < 1$，来自X的一个样本$(X_1,X_2,\cdots, X_n)$确定的两个统计量，$\theta=\theta(X_1,X_2,\cdots, X_n)$和$\bar{\theta}=\theta(X_1,X_2,\cdots, X_n) \quad (\theta < \bar{\theta})$ +对于任意的$\theta \in \Theta$满足， +$$ +P\{\underline{\theta}(X_1,X_2,\cdots, X_n) < \theta < \bar{\theta}(X_1,X_2,\cdots, X_n) \} \ge +$$ +则称随机区间$(\underline{\theta}, \bar{\theta})$是 置信水平为 $1- \alpha$ 的置信区间。 +$\underline{\theta}$为置信下限，$\bar{\theta}$为置信上限，$1- \alpha$为置信水平。 + +## 5.1 置信区间 + +--- + +## 6. 10. 线性回归分析和方差分析 + +bid: `2022102509540400000000000001` + +## 10.1 线性回归分析 +--- +线性回归分析中，通常要求$x$为普通变量，是可控制的变量，Y是随机变量，是可以观察但不可控制的变量。如$x$是施肥量，Y是产量。 + +### 10.1.1 线性回归模型 +>   设$x$是普通变量，Y是随机变量，且 +$$ +Y = \alpha + \beta x + \varepsilon, \quad \varepsilon \sim N(0,\sigma^2) +\tag{10.1.1} +$$ +其中，$\alpha,\beta,\sigma^2$是不依赖于 $x$ 的未知参数，称此模型为一元线性回归模型。 +  易见，此时 +$$ +Y \sim N(\alpha + \beta x,\sigma^2) +\tag{10.1.2} +$$ +称 $Y$ 的数学期望 +$$ +\tilde{Y} = E(Y) = \alpha + \beta x +\tag{10.1.3} +$$ +为 $Y$ 关于 $x$ 的线性回归函数，$\alpha,\beta$ 为回归系数，$x$ 为回归变量。 +  取得样本观测值 $(x_1,y_1),(x_2,y_2),\cdots,(x_n,y_n)$，若能得到$\alpha,\beta$的点估计$\hat{\alpha},\hat{\beta}$,称 +$$ +\tilde{Y} = \hat{\alpha} + \hat{\beta} x +\tag{10.1.4} +$$ +为线性回归方程。 + +### 10.1.2 α，β 和 σ2的极大似然估计及性质 + +  取的样本观测值$(x_1,y_1),(x_2,y_2),\cdots,(x_n,y_n)$ 后，由(10.1.2)，得到似然函数 +$$ +L(\alpha,\beta,\sigma^2)= \prod_{i=1}^{n} f(x_i;\alpha,\beta,\sigma^2) +$$ +$$ += \prod_{i=1}^{n} \frac{1}{\sqrt{2\pi}\sigma}e^{-\frac{(y_i - (\alpha + \beta x_i))^2}{2\sigma^2}} +$$ +$$ += \frac{1}{(\sqrt{2\pi}\sigma)^n}e^{\sum_{i=1}^{n}-\frac{(y_i - (\alpha + \beta x_i))^2}{2\sigma^2}} +$$ +$$ += (2\pi)^{-\frac{n}{2}}(\sigma)^{-\frac{n}{2}} e^{-\frac{1}{2\sigma^2} \sum_{i=1}^{n}[ y_i - (\alpha + \beta x_i)]^2} +$$ + +从而有 +$$ +\ln{L(\alpha,\beta,\sigma^2)}= -\frac{n}{2}\ln(2\pi) -\frac{n}{2}\ln \sigma^2 - \frac{1}{2\sigma^2} \sum_{i=1}^{n}[ y_i - (\alpha + \beta x_i)]^2 +$$ +故而取对数方程组,对个参数取偏导 +$$ +\begin{cases} +\frac{\large{\partial{(\ln (\alpha,\beta,\sigma^2))}}}{\large{\partial{\alpha}}} = \frac{\large{1}}{\large{\sigma^2}}\sum_{i=1}^{n}( y_i - (\alpha + \beta x_i)) = 0\\ +\frac{\large{\partial{(\ln (\alpha,\beta,\sigma^2))}}}{\large{\partial{\beta}}} = \frac{\large{1}}{\large{\sigma^2}}\sum_{i=1}^{n}x_i( y_i - (\alpha + \beta x_i)) = 0\\ +\frac{\large{\partial{(\ln (\alpha,\beta,\sigma^2))}}}{\large{\partial{\sigma^2}}} = - \frac{\large{n}}{\large{2\sigma^2}} + \frac{\large{1}}{\large{2\sigma^4}} \sum_{i=1}^{n}[ y_i - (\alpha + \beta x_i)]^2 = 0 +\end{cases} +$$ +整理为关于 $\alpha,\beta,\sigma^2$ 的方程组。 +$$ +\begin{cases} +n\alpha +\beta\sum_{i=1}^{n}x_i=\sum_{i=1}^{n}y_i\\ +\alpha\sum_{i=1}^{n}x_i + \beta\sum_{i=1}^{n}x_i^2 = \sum_{i=1}^{n}x_i y_i\\ +\sigma^2=\frac{1}{n}\sum_{i=1}^{n}[y_i - (\alpha + \beta x_i)]^2 +\end{cases} +$$ +解得$\alpha,\beta,\sigma^2$的最大似然估计值为 +$$ +\begin{cases} +\hat{\alpha} = \bar{y} - \hat{\beta}\bar{x}\\ +\hat{\beta} = \frac{s_xy}{s_xx}\\ +\hat{\sigma}^2= \frac{1}{n}\sum_{i=1}^{n}[y_i - (\hat{\alpha} + \hat{\beta} x_i)]^2 +\end{cases} +\tag{10.1.5} +$$ +其中 +$$ +s_{xy}=\sum_{i=1}^{n}(x_i-\bar{x})(y_i-\bar{y})=\sum_{i=1}^{n}x_iy_i -n\bar{x}\bar{y} +\tag{10.1.6} +$$ +$$ +s_{xx}=\sum_{i=1}^{n}(x_i-\bar{x})^2=\sum_{i=1}^{n}x_i^2 -n\bar{x}^2 +\tag{10.1.7} +$$ +(10.1.5)，(10.1.6)，(10.1.7)中，观测值 $y_i$ 改为 $Y_i$ 则得到相应的最大似然估计量 +$$ +\begin{cases} +\hat{\alpha} = \bar{Y} - \hat{\beta}\bar{x}\\ +\hat{\beta} = \frac{s_xY}{s_xx}\\ +\hat{\sigma}^2= \frac{1}{n}\sum_{i=1}^{n}[Y_i - (\hat{\alpha} + \hat{\beta} x_i)]^2 +\end{cases} +\tag{10.1.5} +$$ +   注意，$\alpha$ 和 $\beta$ 的最大似然估计值是似然函数中e的指数部分 +$$ +Q(\alpha,\beta)= \sum_{i=1}^{b}[y_i - (\hat{\alpha} + \hat{\beta} x_i)]^2 +$$ +达到最小的估计，所以 $\alpha$ 和 $\beta$ 的最大似然估计 $\hat{\alpha}$ 和 $\hat{\beta}$ 又叫做最小二乘估计。 +  事实上，$Q(\hat{\alpha},\hat{\beta})$ 是数据$(x_i,y_i)$对估计$\hat{y}=\hat{\alpha}+\hat{\beta}x_i$ 的变差平方和。最小二乘估计使数据点到回归线的垂直距离平方和达到最小，而且回归线是通过点 $(\bar{x},\bar{y})$. + +## 10.2 单因素试验的方差分析 +--- +### 10.2.1单因素实验的方差分析模型 +> 若实验中，只让一个因素A变化，而让其他因素保持不变，这样的试验称为单因素试验。 + +--- diff --git a/AI/mechine learning/quantitative trading.md b/AI/mechine learning/quantitative trading.md new file mode 100644 index 0000000..00e90a7 --- /dev/null +++ b/AI/mechine learning/quantitative trading.md @@ -0,0 +1,1075 @@ +# quantitative trading + +> 来源：原 mongodb 集合 `t_blog` · 整理日期：2026-08-25 +> 分类 ID：`2022051700024800000000000003` · 排序：9 · 文章数：10 + +## 目录 + +1. [vnpy application](#vnpy-application) +2. [统计学・数学・線形代数](#统计学数学線形代数) +3. [保证金实例](#保证金实例) +4. [工具函数](#工具函数) +5. [python虚拟环境](#python虚拟环境) +6. [量化投资与机器学习1](#量化投资与机器学习1) +7. [线性代数](#线性代数) +8. [高等数学（上）数列，函数，极限](#高等数学上数列函数极限) +9. [高等数学（上）导数和微分](#高等数学上导数和微分) +10. [高等数学（上）积分和微分方程](#高等数学上积分和微分方程) + +--- + +## 1. vnpy application + +bid: `2022051700024900000000000004` + +## 概述 +vnpy doc + + +- 分析工具 +> numpy, pandas +> ta-lib 这个安装 不能用pip，需要进这个链接用whl的方式安装。 +https://www.lfd.uci.edu/~gohlke/pythonlibs/#TA-Lib +可以用搜寻快速找到(搜寻ta-lib) + +- 可视化工具可視化 +> Matplotlib + +- IDE +> Jupyter +> NoteBook +> Spyder +> pycharm + +- 数据接口 +> Tushare +> DataYes +> Wind +> RICEQUANT +> + + +## python 安装 + + 这个需要说一下，因为我们是需要使用spyder的，还有一些其他工具，如果多项目，不同版本控制的话，暂时没必要搞虚拟环境venv。 + 从官网下载installer，安装添加path即可，我推荐3.8版本，不高不低，适配性好一下，暂时学习阶段够用。 + 如果后期实盘操作，我可能做云服务器，通过kubernetes来操作，毕竟云服务器额网络环境更稳定些。 + +> point! +> ADD PATH to env + +## anaconda + +这个不用说了，集合了python的各种ide + + +## pandas + +> pandas version: 1.3. +[document](https://pandas.pydata.org/pandas-docs/version/1.3/index.html) + +Pandas 的数据结构主要是 +Series(一维数组)， DataFrame(二维数组) +> 基本上可以认为拿到一列或者一行数据的话就是Series，范围数据就是DF + +## spyder + + 这个工具的话，临时对数据显示 + 可能安装提示要安装： + + # 直接从安装页面copy的话- 这个符号 可能会变，导致说找不到模块 + pip install spyder-kernels + +## C++ + +> https://visualstudio.microsoft.com/zh-hans/visual-cpp-build-tools/ +> 使用C++桌面开发 +> 还有C++14 也是需要的 +> https://blog.csdn.net/m0_71983822/article/details/125470192 + +## vnpy 安装 + +首先 vnpy的组件化之后，GitHub、仓库就变的很多了 +我们需要按需求 clone 工程 +- 主体工程 +https://github.com/vnpy/vnpy clone即可 + +- 各个组件一览 +https://github.com/vnpy + + > 我们需要的组件按需导入pip install ....... + + > 我们选ctp 期货接口 https://github.com/vnpy/vnpy_ctp + + > 我们使用mongo 数据库 https://github.com/vnpy/vnpy_mongodb + +## vnpy 核心组件 +### EventEngine +事件引擎，事件驱动引擎，作为事件驱动型交易程序的核心。 +### CtpGateway +CTP的交易接口， + +--- + +## 2. 统计学・数学・線形代数 + +bid: `2022082419545600000000000001` + +## 希腊字母 + +> α　アルファ +> λ　ラムダ +> σ シグマ +> ρ　ロー + +## 数学期望 +> mathematic expectation +期望和平均值的主要区别是：期望主要是针对大群体数据的计算，是通过抽样的结果去预测整个群体的“期望值”；平均值主要针对小群体的计算，得到的结果是准确无误的，不会有模糊的概念。 +1、均值（mean value）是针对既有的数值（简称母体）全部一个不漏个别都总加起来，除以总母体个数做平均值，就叫做均值。此法针对小群体做此加总后除以个数得到均值的方法，是很准确无误的，这个得到的均值是准确的，不会有模糊的概念。 +平均值，有算术平均值，几何平均值，平方平均值（均方根平均值，rms），调和平均值，加权平均值等。 +2、当这个数群（data group）的数量（numbers）很大很多时，我们只好做个抽样（sampling），并“期望”透过抽样所得到的均值，去预测整个群体的“期望值（expectation value）”。 +在概率论和统计学中，期望值（或数学期望、或均值，亦简称期望，物理学中称为期待值）是指在一个离散性随机变量试验中每次可能结果的概率乘以其结果的总和。 + +--- +## 加权平均 + +样本中变量X 出现的概率 Z +> x(X1Z1 + X2Z2 + ... + XnZn) / n + + + +--- +## 方差 +方差刻画了随机变量的取值对于其数学期望的离散程度。（标准差、方差越大，离散程度越大） + +> variance + +--- +## 协方差 +> Covariance +在概率论和统计学中，协方差用于衡量两个变量的总体误差。 +而方差是协方差的一种特殊情况，即当两个变量是相同的情况。 +期望值分别为E[X]与E[Y]的两个实随机变量X与Y之间的协方差Cov(X,Y)定义为： + +> Cov(X,Y) +> = E[(X-E[X])(Y-E[Y])] +> = E(XY -XE[Y] -YE[X] + E[X]E[Y]) +> = E(XY) - E[X]E[Y] + + +--- +## 相关系数 corrcoef +反映两变量间线性相关关系的统计指标称为相关系数 ρXY +> X 增大 Y 增大，X 减小 Y减小 ->> 正相关 +> X 增大 Y 减小，X 减小 Y增大 ->> 负相关 +> X 增大 Y 不变，X 不变 Y增大 ->> 不相关 + +Var[X] 为 X 的方差 +Var[Y] 为 Y 的方差 + +> corrcoef(X, Y) = ρXY = Cov(X,Y) / (√X √Y) +相关系数 有以下特性 +> |ρXY|≦1 + +--- + +## 3. 保证金实例 + +bid: `2022082419546500000000000002` + +## 期货的本质就是保证金交易 + + 以 为 菜粕（cai po）为例： + 合约代码：RM301 // 这说明是23年01月到期 + 交易单位：10吨/手 + 最小交易单位：1手 + 最小变动价格：1元/吨 + 最低保证金： 9% + 最后交割日期：2023-01-19 + 最后交易日期：2023-01-16 + 合约类型：商品期货 + 交割方式：实物交割 + + 当天晚上8：08 时间的 菜粕的价格是 3020元/吨 + 如果买入，那么根据最小的交易单位为1手，即10吨，那么我们需要10 吨 x 3020 元/吨 = 30200 元 + 根据保证金为9%原则，我们需要的保证金为 30200 x 0.09 = 2718 元，这也是为什么期货的开户最小资金为5000元的原因。 + 当我们买了1手，即10吨的期货，花掉了2718元的保证金，那么剩余的可利用资金就是 5000 - 2718 = 2282 元 + 我们知道 菜粕 价格变动1元的话，一手，即10吨的变动就是10元 + 菜粕 价格变动10元的话，一手，即10吨的变动就是100元 + 菜粕 价格变动100元的话，一手，即10吨的变动就是1000元 + 以此类推，菜粕 价格变动228元的话，一手，即10吨的变动就是2280元，如果 228元的变动是价格增加，恰好，你是买入，那么此时： + 你的 账户价值为： 5000 元 + 2280元 + 如果 228元的变动是价格减少，你是买入，那么此时： + 你的账户价值为： 5000 元 - 2280元 + // 实际上为 5000元 - 10 吨 * （2718 - 2490） + // 即买了10吨 但是价格降了228元 所以赔了2280元来考虑 + 如果 + 我们通过历史价格观察可以知道，菜粕的价格波动为2400元 到4000元，通常情况下的波动为 2400到 3200元左右 + 所以 对于 228元的价格波动来说，是远远满足不了 2400 到 3200元的波动的 + +## pricetick + + 期货的价格最小一跳单位 1.0 + +## + +--- + +## 4. 工具函数 + +bid: `2022082920585700000000000001` + +## pandas +--- +### 1. Rolling + +> rolling 函数 【Rolling window functions】 + +[Document](https://pandas.pydata.org/pandas-docs/version/1.3/reference/api/pandas.Series.rolling.html#pandas.Series.rolling) + + Series.rolling(window, min_periods=None, center=False, win_type=None, on=None, axis=0, closed=None, method='single') + DataFrame.rolling(window, min_periods=None, center=False, win_type=None, on=None, axis=0, closed=None, method='single') + + the Rolling function will return a Rolling Object. + +- Rolling.mean 滚动平均(rolling mean) + +### 2.dropna 関数 +用来剔除Dataframe中的空值。 + +> Dataframe = Dataframe.dropna() + + +## talib +--- +### Simple Moving Average，SMA + +> 数学公式： SMA = (C1 + C2 + C3 + C4 + …… + Cn) / n + +> talib.SMA(data, 20) + +### + +## matplotlib +--- +### candlestick_ohlc (K线) +> pip install mpl_finance + + +## numpy +--- +### corrcoef 関数 +corrcoef函数用来计算矩阵相关系数 +(1)corrcoef(x)：若x为一个矩阵，返回的则是一个相关系数矩阵，其尺寸与矩阵x一样。 + +(2)corrcoef(x, y)：计算列向量x、y的相关系数，要求x、y具有相等的元素个数。如果x、y是矩阵，那么corrcoef函数会将其转换为列向量，相当于corrcoef([x(:),y(:)])。 +> corrcoef(x, y) + +> +### std 标准差 +> np.std(df) +### + +--- + +## 5. python虚拟环境 + +bid: `2022083108519100000000000002` + +## python虚拟环境 +--- +一台电脑上，用python2运行了A程序，又想用python3运行B程序。 +而通常程序运行的python环境都是定义在环境变量中的。 +遇到这种情况怎么办，当然是隔离运行环境了。 +生成程序A和程序B各自用的环境就是所谓的虚拟环境了 + +## 安装虚拟环境前提 +--- +- 安装python 3.3 以上版本 + +## venv 模块 +--- +Python3.3 之后，可以用模块 venv 代替 virtualenv 工具，好处是不用单独安装，3.3 及之后的 +版本，都可以通过安装好的 Python 来创建虚拟环境: + + # 创建了python虚拟环境，生成myvenv文件夹 + python -m venv myvenv + + # 生成myvenv文件夹目录结构 + # windows + $ cd .\myvenv\ + $ dir + # ---------------------------------------------------- + Mode LastWriteTime Length Name + ---- ------------- ------ ---- + d----- 2022/6/14 11:31 Include + d----- 2022/6/14 11:31 Lib + d----- 2022/6/14 11:31 Scripts + -a---- 2022/6/14 11:31 122 pyvenv.cfg + # ----------------------------------------------------- + + # linux + $ cd myvenv + $ ll + +## 激活 +--- +虚拟环境创建好后，需要激活才能在当前命令行中使用，可以理解成将当前命令行环境中 PATH 变量 +的值替换掉 +- Windows 系统中，激活脚本路径是 \Scripts\activate.bat，如果是 powershell 命令行，脚本换成 Activate.ps1 , 注意将 换成你自己的虚拟环境目录 + + # CMD 命令提示符下 + $ cd C:\Users\xxxx\xxx\myvenv\Scripts + $ activate.bat + + # powershell下 + $ cd C:\Users\xxxx\xxx\myvenv\Scripts + $ Activate.ps1 + +- Linux 系统中，激活脚本路径是 /bin/activate，默认脚本没有执行权限，要么设置 +脚本为可执行，要么用 source 命令执行 + + # 设置为可执行文件 + $ chmod 777 myvenv/bin/activate + + # source 命令执行 + $ source myvenv/bin/activate + +## 退出环境 +--- + + # 直接执行 deactivate 即可， 在虚拟环境下，该命令可以直接执行。 + deactivate + +## 结合开发工具 VS code 使用 +--- +同时按下 Ctrl+Shift+P，在弹出列表下，选择 Python： select Interpreter +然后选择相应的python解释器即可。 + +--- + +## 6. 量化投资与机器学习1 + +bid: `2022090519500800000000000003` + +## 监督学习 +监督学习：我们教计算机如何做事情 +> 我们给算法一个数据集，并且给定正确答案； +> 数据集中的每个样本都有相应的正确答案，再根据这些样本作出预测； +> 即监督学习中的样本不是都相同的，每个样本都有自己的标签。 + + +## 非监督学习 +非监督学习：我们让计算机自已学习 +> 非监督学习是指：没有标签这一概念，所有的数据都是一样的，故无监督学习中，只有一个数据集 + +--- +## 基础概念 + +### 先验概率 + +### 后验概率 + +# + + + +## 机械学习算法基础案例 + +最为广泛的两种分类模型是 **决策树模型** **朴素贝叶斯模型** +### 朴素贝叶斯算法 +朴素贝叶斯模型（Naive Bayesian Model，NBM） + +特点： + + 参数很少，对缺失数据不太敏感 + +算法原理： + +> 设有样本数据集，*D={d1, d2, ・・・, dn}* +> 对应样本数据的特征属性集为*X={x1, x2, ・・・, xd}* +> 类变量为*Y={y1, y2, ・・・, ym}*, 即D可以分为ym分类 +其中 相互独立且随机，则 的先验概率 + +--- + +## 7. 线性代数 + +bid: `2022090711097700000000000004` + +## 1. 线性方程 +--- +> 线性方程也称一次方程式 + +一元一次方程表示一个点 $2x=1$ +二元一次方程表示一条直线 $2x + 3y = 1$ +三元一次方程表示一个平面 $3x + 4y + 5z = 20$ + +由两个直线（不平行）相交可以确定一个点 +由两个平面（不平行）相交可以确定一条直线 +由3个平面（不平行）相交可以确定一个点 + +> 齐次方程 与 非齐次方程 + +齐次线性方程组的常数项全部为 0，非齐次方程组的常数项不全为 0。 +齐次$ \pmb{A}\pmb{x}=0$ +非齐次$ \pmb{A}\pmb{x}=\pmb{b}$ + + +## 2. 矩阵的初等变换与线性方程组 +--- +### 2.1 矩阵的初等变换 + +> 矩阵的初等变换 + +・ 对换两行（列），记作 $ r_i \leftrightarrow r_j$ ($ c_i \leftrightarrow c_j$) +・ 以数 $k \neq 0 $ 乘某一行（列）中的所有元，记作 $ r_i \times k$ （ $ c_i \times k$） +・ 把某一行（列）所有元的 k 倍加到另一行（列）对应的元上去，记作 $ r_i \times kr_i$ （ $ c_i \times kc_i$ ） + +> 矩阵等价 + +如果矩阵 $A$ 经过有限次初等变换变成矩阵 $B$ ，就称矩阵 $A$ 与矩阵 $B$ 等价，记作 $A \sim B$. +矩阵等价满足 +・ $A \sim B$ +・ 若 $A \sim B$ ，则 $B \sim A$ +・ 若 $A \sim B$ ，$B \sim C$，则 $A \sim C$ + +### 2.2 矩阵的秩 + +`子式` +在 $m \sim n$ 矩阵 $A$ 中，任取 $k$ 行 $k$ 列，位于这些行列交叉处的 $k^2$ 个元素，不改变它们在 $A$ 中所处的位置次序而得的 $k$ 阶行列式，称为矩阵 $A$ 的 $k$ 阶子式。 +`秩` +若矩阵 $A$ 中存在一个不为零的 $r$ 阶子式，且所有 $r + 1$ 阶子式全为零，那么数 $r$ 称为矩阵 $A$ 的秩，记作 $R(A)$. 规定零矩阵的秩为 0 . + +### 2.3 方程组的解 + +对于方程组: +$ x_1 + x_2 = 1$ +$ 2x_1 + x_2 = 2$ + +我们得到系数矩阵 $\pmb{A}$ +$$ +\pmb{A}=\begin +{pmatrix} +1 & 1 \\ +2 & 1 \\ +\end +{pmatrix} +$$ +未知项矩阵 $\pmb{b}$ +$$ +\pmb{x}=\begin +{pmatrix} +x_1 \\ +x_2 \\ +\end +{pmatrix} +$$ +常数矩阵 $\pmb{b}$ +$$ +\pmb{b}=\begin +{pmatrix} +1 \\ +2 \\ +\end +{pmatrix} +$$ +有 +$$ +\pmb{A}\pmb{x}=\pmb{b} +$$ + +最重要的性质就是 $R(\pmb{A}) = R(\pmb{A},\pmb{b}) =n$ 时，齐次方程有唯一解。 + +## 3. 向量空间Vector space +--- +### 3.1 ベクトル（Vector） +两个向量相等：长度相等且方向相同的两个向量叫做相等向量 +单位矢量：长度为1的矢量（即单位矢量）， +一个三维的向量可以由三个维度的单位矢量称相应向量在该维度的模来表示。 + +### 3.2 多维空间的向量表示 +行向量 [1, 2, 3] +列向量 [1, 2, 3]T +行向量和列向量本质上没有区别。 + +### 3.3 向量组 + +> 向量组的线性组合 + +给定向量组$A: a_1, a_2, ..., a_n$，对于任何一组实数$k_1, k_2, ..., k_n$ 表达式 +$$ +\sum_{i=1}^{n}k_ia_i +$$ +, 称为向量组A的一个线性组合。$k_i(1\leq{}i\leq{}n)$称为这个线性组合的系数。 + +> 向量的线性表示 + +给定向量组$A: a_1, a_2, ..., a_n$ 和向量 **b**，如果存在一组实数$k_1, k_2, ..., k_n$使 +$$ +b = \sum_{i=1}^{n}k_ia_i +$$ +则称向量**b**能由向量组A线性表示。 +向量组A可以写成n列的矩阵来表示$A=(a_1, a_2, ..., a_n)$ +则向量b能由向量组A线性表示可写成 +$$ +b=A\begin{pmatrix} +k_1 \\ +k_2 \\ +\vdots \\ +k_n \\ +\end{pmatrix} +$$ + +> 向量组的线性表示 + +给定向量组$A: a_1, a_2, ..., a_m$ 和向量 $B: b_1, b_2, ..., b_l$，若B中的每一个向量都能由A线性表示，就称向量组B能由向量组A线性表示。 +$$ +B=A\begin{pmatrix} +k_{11} & k_{12} & \cdots & k_{1l} \\ +k_{21} & k_{22} & \cdots & k_{2l} \\ +\vdots & \vdots & \ddots & \vdots \\ +k_{m1} & k_{m2} & \cdots & k_{ml} \\ +\end{pmatrix} +$$ + +> 向量组等价 + +给定向量组A和B，如果它们能互相线性表示，则称这两个向量组等价。 + +$$ +B=A\begin{pmatrix} +k_{11} & k_{12} & \cdots & k_{1l} \\ +k_{21} & k_{22} & \cdots & k_{2l} \\ +\vdots & \vdots & \ddots & \vdots \\ +k_{m1} & k_{m2} & \cdots & k_{ml} \\ +\end{pmatrix} +$$ + +$$ +A=B\begin{pmatrix} +q_{11} & q_{12} & \cdots & q_{1l} \\ +q_{21} & q_{22} & \cdots & q_{2l} \\ +\vdots & \vdots & \ddots & \vdots \\ +q_{m1} & q_{m2} & \cdots & q_{ml} \\ +\end{pmatrix} +$$ + +有解， + +### 3.4 向量组的线性相关性 + +> 向量组的线性相关性 + +给定向量组$A: a_1, a_2, ..., a_n$，如果存在不全为零的数$k_1, k_2, ..., k_n$，使 +$$ +\sum_{i=1}^{n}k_ia_i = 0 +$$ +则称向量组A是线性相关的，否则称它是线性无关的。 + +`※注意： ` +`包含0向量的向量组总是线性相关的` +`线性相关就意味着，向量组中的任意一个向量都可以由其他向量线性表示` + +### 3.5 向量组的秩 + +> 向量组的秩 + +给定向量组A，如果能在A中选出r个向量$a_1，a_2, ..., a_r$ 满足 +・ 向量组 $A_0: a_1, a_2, ..., a_r$ 线性无关。 +・ 向量组A中任意r + 1个向量都线性相关。 + +则称向量组$A_0$是向量组A的一个最大线性无关组，简称最大无关组，r称为向量组A的秩，记作$R_A$，意思是极大线性无关组所含向量的个数。 + +> 定理 矩阵的秩等于它的列向量组的秩，也等于它的行向量组的秩。 + +### 3.6 线性方程组解的结构 + +对于一个向量方程 $Ax=0$: +・ 若 $x = \xi_{1}, x = \xi_{2}$ 是该方程的解，则 $x = \xi_{1} + \xi_{2}$ 也是该方程的解。 +・ 若 $x = \xi_{1}$ 是该方程的解，则 $x = k\xi_{1}(k \in R)$ 也是该方程的解。 + +> 基础解系 + +齐次线性方程组的解集的最大无关组称为该齐次线性方程组的基础解系。 + + +## 3. + +--- + +## 8. 高等数学（上）数列，函数，极限 + +bid: `2022093010286500000000000007` + +[高等数学](https://www.bilibili.com/video/BV1864y1T7Ks/?spm_id_from=333.999.0.0) + +## 第一部分 高等数学学习路线 + +高等数学分为上下两册，并且大体上分为极限，导数和积分三个部分，而每个部分都分为一元函数和多元函数 + +> 极限 + +一元函数 $ y = f(x)$ + 多元函数 $ z = f(x\,y)$ +应用 ---->>主要是求极限的各种方法 + +> 导数， + +一元函数 + +$$ +\frac{dy}{dx} +$$ + +多元函数(偏导数) $ z = f(x\text{,}y)$ +应用 ---->>物理应用，经济应用和几何应用，解析几何应用 + +> 积分 + +一元函数 （定积分和不定积分） +多元函数 （重积分，曲线积分和曲面积分) +应用 ---->>物理应用，经济应用和几何应用，解析几何应用 + +## 第一章 函数与极限 + +### 1.1 映射 + +以下概念的理解 + +> 满射 +> 单射 +> 假设有一个单射 y = f(x), 定义逆映射 $ f^{-1}$ +> 复合映射$ fog $ +> **注意**，映射 的两头 不都是数集，这个很重要，比如说，映射的值域是 学生名称，映射的定义域是学生号 + +### 2.2 函数 + +函数是一种特殊的映射，定义域和值域都是数集。 +函数的两个要素，定义域(D)，和映射法则(f) + +> **特殊的函数** +> 单调函数对应的单射 +> 常值函数 +> 绝对函数 +> 符号函数，即分段常值函数 +> 取整函数 y = [x] 不超过 x 的最大整数，[-1.3] = -2 [0.36] = 0 [3] = 3 + +> **函数的特性** +> ならば記号　 ⇒ 日本語入力（ならば） +> 全て記号　 ∀ 　日本語入力（すべて） +> 存在記号　 ∃ 　日本語入力（存在） +> 同値記号　 ⇔ 　日本語入力（同値）とう +> 属する記号　 ∊ 　日本語入力（属する） +> 無限記号　 ∞ 　日本語（無限） + +> 性质 +> 有界性，最重要的有界性质：若 f(x) 在 E 上既有上界还有下界，则称 f(x)有界，否则是无界，「f(x)在 E 上有界」⇔「∀M>0, $∀x$ ∊ $E$,有 f(x)≦M」 +> 单调性，单调递增和单调递减 +> 奇偶性，偶函数 f(x) = f(-x), f(x) = -f(-x) +> 周期性，f(x) = f(x + T)，则，f(x)是以 T 为周期的周期函数 +> 反函数和复合函数 + +> 函数的四则运算 + +> 基本初等函数 +> 幂函数，指数函数，对数函数，三角函数，反三角函数 +> 分段函数不是基本函数 + +### 2.3 数列极限 + +极限严格数学定义 +如果用足够小的正实数 ε「イプシロン、無視できる小さいぐらい値と考える」 +作为衡量接近程度的指标，则，当|xn-1| < ε、表示在 ε 指标下足够接近，无论 ε 是如何小的正数，总可以找到正整数 N，使数列除了开始的 N 项以外，自第 N+1 项开始，后面的一切项都在 a=1 的 ε 邻域 U(1, ε)内， +**收敛数列的性质** +定理 1：收敛数列，极限的唯一性 +定理 2：收敛数列，一定有界 +定理 3：收敛数列的保号性 +定理 3：收敛数列的子收敛数列极限是相同的。 + +### 2.4 函数的极限 + +**自变量趋于正无限大时的函数的极限** +定義： +对于任意给定的正数 ε（ε 足够小），总存在$X > 0$, $∀x > X$时，满足$|f(x) - A| < ε$ +此时，称常数 A 为函数$f(x)$在$x→+\infty$时的极限。 +$ε-X$ + +$$ +\lim_{x→+\infty}f(x) = A +$$ + +$∀ε>0$, $∃X>0$, $x>X$时,有$|f(x) - A| < ε$ +**自变量趋于负无限大时的函数的极限** + +$$ +\lim_{x→-\infty}f(x) = A +$$ + +$∀ε>0$, $∃X>0$, $x<-X$时,有$|f(x) - A| < ε$ +**自变量趋于无穷时的函数的极限** + +$$ +\lim_{x→\infty}f(x) = A +$$ + +$∀ε>0$, $∃X>0$, $|x|>X$时,有$|f(x) - A| < ε$ + +### 2.5 无穷小和无穷大 + +无穷小 + +$$ +\lim_{x→X}f(x) = 0 ⇔ \text{x趋近于X的极限是0,我们就说无穷小} +$$ + +无穷大 + +$$ +\lim_{x→X}f(x) = \infty ⇔ \text{x趋近于X的极限是} \infty \text{, 我们就说无穷大} +$$ + +无穷小和无穷大，是一个函数，不是一个数，无穷大是无界的， + +### 2.6 极限存在法则，两个重要的极限 + +**1.夹逼准则** +$∃n_0$ ∊ $N$, 当$n$大于$n_0$时，有 + +$$ +y_n ≦x_n ≦ z_n +$$ + +如果 + +$$ +\lim_{n→+\infty}y_n = a \text{,} \lim_{n→+\infty}z_n = a +$$ + +则 + +$$ +\lim_{n→+\infty}x_n = a +$$ + +**第一个重要的极限** + +$$ +\lim_{x→0} \frac{sinx}{x} = 1 +$$ + +证明： +由画图可知，在 00 的某一个邻域内定义，如果， + +$$ +\lim_{Δx→0} Δy = \lim_{Δx→0} [f(x_0 + Δx) - f(x_0)] = 0 +$$ + +那么则称函数 y=f(x)在点 x0 出连续。 +即 + +$$ +\lim_{x→x_0} f(x) = f(x_0) +$$ + +那么则称 x 在 x0 处连续 +**左连续** +**右连续** + +### 2.9 连续函数的运算和初等函数的连续性 + +1. 连续函数的商积和差，也是连续函数（分母不等于 0 时） +2. 反函数和复合函数的连续性 +3. 初等函数在定义域内都是连续的 +还 + +--- + +## 9. 高等数学（上）导数和微分 + +bid: `2022100613288800000000000008` + +## 第二章 导数和微分 + +### 2.1 导数 + +### 2.2 导数的求导法则 + +**和差积商的求导法则** + +$$ +(1)[u(x) + v(x)]^{'} = u^{'}(x)±v^{'}(x); +$$ + +$$ +(2)[u(x)v(x)]^{'} = u^{'}(x)v(x) + u(x)v^{'}(x); +$$ + +$$ +(3)[\frac{u(x)}{v(x)}]^{'} = \frac{u^{'}(x)v(x) - u(x)v^{'}(x)}{v^{2}(x)}(v(x)≠0); +$$ + +**反函数的求导法则** + +$$ +(2)[f^{-1}(x)]^{'} = \frac{1}{f^{'}(x)} +$$ + +**复合函数的求导法则** +如果$u = g(x)$在点 x 可导，而$y= f(u)$在点 u=g(x)可导，则复合函数$y = f[g(x)]$在点 x 可导，且其导数为 + +$$ +\frac{dy}{dx}=f^{'}(u) \text{・} g^{'}(x) = \frac{dy}{du} \text{・} \frac{du}{dx} +$$ + +**基本求导法则和导数公式** +(1) $(C)^{'}=0$ +(2) $(x^{\mu})^{'}=\mu x^{\mu -1}$ +(3) $(sin x)^{'}=cos x$ +(4) $(cos x)^{'}=-sinx$ +(5) $(e^{x})^{'}=e^{x}$ +(6) $(a^{x})^{'}=a^{x}\ln{a}$ +(7) $(\log_{a}x)^{'}=\frac{1}{x\ln{a}}$ +(7) $(\ln{x})^{'}=\frac{1}{x}$ + +### 2.3 高阶导数 + +二阶导数 + +$$ +y^{''} = (y^{'})^{'} \text{,} \frac{d^{2}y}{dx^{2}}=\frac{d}{dx}(\frac{dy}{dx}) +$$ + +### 2.4 隐函数 + +一般的，方程$F(x,y)=0$，x 在一个区间内，存在一个这个方程的唯一的值 y，那么我们就说方程$F(x,y)=0$在 x 这个区间内存在隐函数。 + +### 2.5 函数微分 + +**定义** +设函数$y= f(x)$在某一区间内有定义，$x_0$及$x_0+Δx$在这个区间内，如增量 + +$$ +Δy = f(x_0 + Δx) - f(x_0) +$$a + +可表示为 + +$$ +Δy = AΔx + o(Δx) +$$ + +其中 A 是不依赖于 Δx 的常熟，那么称函数$y=f(x)$在点$x_0$是可微的，而$AΔx$叫做函数$y=f(x)$在点$x_0$相应于自变量增量 Δx 的微分，记作 dy +即 + +$$ +dy=AΔx +$$ + +## 第三章 微分中值定理和导数的应用 + +### 3.1 微分中值定理 + +**费马定理** +设函数$f(x)$在$x_0$的某个邻域$U(x_0)$内有定义，并且在$x_0$处可导，如果对任意的$x$∊$U(x_0)$,有 + +$$ +f(x)≦ f(x_0)\text{あるいは、}f(x)≧ f(x_0) +$$ + +那么，$ f^{'}(x_0) = 0$ +**罗尔定理** +(1) 在闭区间[a, b]上连续； +(2) 在开区间(a, b)上可导； +(3) 在区间端点处的函数值相等，即$f(a) = f(b)$ +那么在(a, b)内至少有一点，$\xi(a < \xi 0$,单调增加 +如果$f^{\prime}(x)<0$,单调递减 +**曲线的凹凸性与拐点** +二阶导数的凹凸性 +如果$f^{\prime\prime}(x)>0$,凹 +如果$f^{\prime\prime}(x)<0$,凸 +**拐点** +凹凸性改变就是拐点 + +### 3.5 函数的极值和最大值最小值 +定理1（必要条件）设函数f(x)在$x_0$处可导，且在$x_0$处取得极值，那么$f^{\prime}(x_0)=0$ +定理2（第一充分条件）设函数f(x)在$x_0$处可导，且在$x_0$处取得极值，那么$f^{\prime}(x_0)=0$ + +### 3.6 曲率 + +### 3.7 方程的近似解 + +--- + +## 10. 高等数学（上）积分和微分方程 + +bid: `2022100614018700000000000009` + +## 第四章 不定积分 +--- +### 4.1 原函数和不定积分的概念 +**定义1** +如果在区间$I$上，可导函数$F(x)$的导函数为$f(x)$，即对任一$x \in I$,都有 +$$ +F^{\prime}(x)=f(x) \quad \text{或} dF(x) = f(x)dx +$$ +那么函数$F(x)$就称为$f(x)$（或$f(x)dx$）在区间$I$上的原函数 + +**原函数存在定理** +连续函数一定有原函数 + +**定义2** +在区间$I$上，函数$f(x)$的带有任意常数项的原函数称为$f(x)$在区间$I$上的不定积分，记作 +$$ +\int f(x)dx, \quad \text{其中记号} \int \text{积分号} +$$ +$f(x)dx$称为被积表达式，x称为积分变量。 +即 +$$ +\int f(x)dx = F(x) + C +$$ +因此，$\int f(x)dx$可以表示$f(x)$的任意一个原函数。 +### 基本积分表 +此处略 ++C +### 不定积分的性质 +基本的四则运算 + +### 4.2 换元积分法 +利用积分表来计算积分式非常有限的，所以把复合函数的微分法反过来求不定积分，利用中间变量代换，得到符合函数的积分法， + +## 第五章 定积分 + +## 第六章 定积分的应用 + +## 第七章 微分方程 + +--- diff --git a/AI/mechine learning/t_blog.json b/AI/mechine learning/t_blog.json new file mode 100644 index 0000000..4f24715 --- /dev/null +++ b/AI/mechine learning/t_blog.json @@ -0,0 +1,2007 @@ +[{ + "_id": { + "$oid": "626e92e3ff47411696bdc503" + }, + "bid": "00000000000004", + "title": "Jvm", + "btId": "00000000000003", + "content": { + "$binary": { + "base64": "IyBKdm0gIwotLS0KSmF2YSBWaXJ0dWFsIE1hY2hpbmXvvIhKdm3vvIlKYXZh6Jma5ouf5py6CuaYr+i3qOW5s+WPsOeahOWFs+mUruWboOe0oOOAggrlr7nkuo5Kdm3pnIDopoHkuobop6PnmoTmnInkuKTlpKfmqKHlnZfvvIzkuIDmmK/lhoXlrZjmqKHlnovvvIzkuozmmK/lnoPlnL7lm57mlLbmnLrliLbjgIIKIyMg5YaF5a2Y5qih5Z6LICMjCi0tLQrpmo/nnYBKYXZh55qE54mI5pys55qE5Y+Y5YyW77yM5YaF5a2Y5qih5Z6L5Lmf5pyJ5LiA5a6a55qE5Y+Y5YyW44CCCuavlOWmgkphdmE45ZCO77yMTWV0YXNwYWNl5Luj5pu/5LqGcGVybWFuZW50IHNwYWNl44CCCuS9huaYr+WGheWtmOaooeWei+i/meS4quaKveixoeamguW/teayoeaciea2iOWkse+8jGphdmHomZrmi5/mnLrlhoXlrZjpgJrluLjooqvliJLliIbkuLrku6XkuIvlh6DkuKrpg6jliIbjgIIKaGVhcDogCnN0YWNrOgpuYXRpdmUgbWV0aG9kIHN0YWNrCueoi+W6j+iuoeaVsOWZqAoKIyMg5Z6D5Zy+5Zue5pS25py65Yi2L0dhcmJhZ2UgY29sbGVjdGlvbnMgIyMKLS0tCuWeg+WcvuWbnuaUtuacuuWItuWMheaLrOeul+azlemDqOWIhuWSjOWghuWGheWtmOWIhumFjeS4pOmDqOWIhuOAggpoZWFw5YaF5a2Y77ya5oyJ54WnamF2YeeahOWvueixoeeahOWtmOa0u+aXtumXtOWIhuS4uuS7peS4i+WHoOS4qumDqOWIhuOAggpZb3VuZyBHZW5lcmF0aW9u77yaCk9sZCBHZW5lcmF0aW9u77yaCueUseS6jk1ldGEgU3BhY2XmmK/kvb/nlKjmnKzlnLDlhoXlrZjvvIzku5bkuI3nrpfliLBoZWFw6YeM6Z2i44CCCkVkZW4gc3BhY2XvvJrmiYDmnInnmoQKCgo=", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 0, + "owner": "3272499474" +},{ + "_id": { + "$oid": "627009d357c0264f499c3113" + }, + "bid": "00000000000003", + "title": "Springboot AbstractApplicationContext", + "btId": "00000000000002", + "content": { + "$binary": { + "base64": "IyMgQWJzdHJhY3RBcHBsaWNhdGlvbkNvbnRleHQKCiAgIEFic3RyYWN0QXBwbGljYXRpb25Db250ZXh0IOaYryBTcHJpbmdCb29055qEIOaguOW/g+W6lOeUqOS4iuS4i+aWh+eItuexu+OAggoKIyMgeC4xIHByb3BlcnRpZXMKCiMjIyBiZWFuRmFjdG9yeVBvc3RQcm9jZXNzb3JzCgojIyMgZW52aXJvbm1lbnQKCiMjIHguMiBtZXRob2RzCgojIyMgcmVmcmVzaAoKICByZWZyZXNoIOaYryBTcHJpbmdib2905ZCv5Yqo5Lit5qC45b+D5pa55rOV44CCCgotIHByZXBhcmVSZWZyZXNoCi0gb2J0YWluRnJlc2hCZWFuRmFjdG9yeQotIHByZXBhcmVCZWFuRmFjdG9yeQotIHBvc3RQcm9jZXNzQmVhbkZhY3RvcnkKLSBpbnZva2VCZWFuRmFjdG9yeVBvc3RQcm9jZXNzb3JzCi0gcmVnaXN0ZXJCZWFuUG9zdFByb2Nlc3NvcnMKLSBvblJlZnJlc2gKLSBmaW5pc2hCZWFuRmFjdG9yeUluaXRpYWxpemF0aW9uCi0gZmluaXNoUmVmcmVzaA==", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 1, + "owner": "3272499474" +},{ + "_id": { + "$oid": "626e9cb157c0264f499c3111" + }, + "bid": "00000000000001", + "title": "谈一下垃圾回收算法", + "btId": "00000000000003", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 1, + "owner": "3272499474" +},{ + "_id": { + "$oid": "6273350ace1c9f5320a2d06f" + }, + "bid": "2022050510233300000000000006", + "title": "S3", + "btId": "2022050510233200000000000005", + "content": { + "$binary": { + "base64": "IyMjIHNpbXBsZSBzdG9yYWdlIHNlcnZpY2UKLS0tCltQcmljZeaWh+aho10oaHR0cHM6Ly9hd3MuYW1hem9uLmNvbS9jbi9zMy9wcmljaW5nLykKUzPnmoTmlLbotLnlhoXlrrnvvIzljIXmi6zvvJoK5a2Y5YKo77yM6K+35rGC77yIaHR0cOivt+axguaVsOmHj++8ie+8jOaVsOaNruS8oOi+k++8iOWuveW4pui0ueeUqO+8ie+8jOWkjeWItu+8iOi3qOWMuuWfn+WSjOS4jei3qOWMuuWfn++8ie+8jOeuoeeQhu+8iOmineWklueahOmrmOe6p+euoeeQhuWKn+iDve+8iQoKCiMjIyBFbmFibGUgUmVxdWVzdGVyIFBheXMKLS0tClvlrpjmlrnmlofmoaNdKGh0dHBzOi8vZG9jcy5hd3MuYW1hem9uLmNvbS96aF9jbi9BbWF6b25TMy9sYXRlc3QvdXNlcmd1aWRlL1JlcXVlc3RlclBheXNCdWNrZXRzLmh0bWwpCuS9nOS4ulNBUOiAg+ivleS4reeahOS4gOmimO+8jOmHjeimgeiAg+Wvn+eahOaYr++8muWtmOWCqOahtueahOaLpeacieiAheWSjOiuv+mXruiAheWIhuW8gOS7mOi0ueOAguS4pOS4quS4jeWQjOeahOS7mOi0uei0puaIt++8jOiuv+mXruiAhemcgOimgei6q+S7vemqjOivgeOAggrlhbPplK7or43vvJoqKkVuYWJsZSBSZXF1ZXN0ZXIgUGF5cyoq77yMKipBV1MgY3JlZGVudGlhbHMqKgoKIyMjIFJlcGxpY2F0aW5nIG9iamVjdHMKLS0tClvlrpjmlrnmlofmoaNdKGh0dHBzOi8vZG9jcy5hd3MuYW1hem9uLmNvbS9BbWF6b25TMy9sYXRlc3QvdXNlcmd1aWRlL3JlcGxpY2F0aW9uLmh0bWwjY3JyLXNjZW5hcmlvKQoqKkNyb3NzLVJlZ2lvbiBSZXBsaWNhdGlvbioqIOi3qOWMuuWfn+WkjeWItiAqKkNSUioqCgoqKlNhbWUtUmVnaW9uIFJlcGxpY2F0aW9uKiog5ZCM5Yy65Z+f5aSN5Yi2ICoqU1JSKio=", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 0, + "owner": "3272499474" +},{ + "_id": { + "$oid": "62733a35ce1c9f5320a2d070" + }, + "bid": "2022050510458100000000000007", + "title": "EC2", + "btId": "2022050510233200000000000005", + "content": { + "$binary": { + "base64": "", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 1, + "owner": "3272499474" +},{ + "_id": { + "$oid": "62733d30ce1c9f5320a2d071" + }, + "bid": "2022050510575300000000000008", + "title": "Route 53", + "btId": "2022050510233200000000000005", + "content": { + "$binary": { + "base64": "", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 2, + "owner": "3272499474" +},{ + "_id": { + "$oid": "62733fb6ce1c9f5320a2d072" + }, + "bid": "2022050511086300000000000009", + "title": "VPC", + "btId": "2022050510233200000000000005", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 3, + "owner": "3272499474" +},{ + "_id": { + "$oid": "62736c29ce1c9f5320a2d074" + }, + "bid": "2022050514188900000000000011", + "title": "Amazon Kinesis", + "btId": "2022050510233200000000000005", + "content": { + "$binary": { + "base64": "5a+55qCH5LqOZmx1bWXvvIxLYWZrYe+8jOWSjGZsaW5r55qE5YiG5biD5byP5LqR6K6h566X5qih5byP44CCClvlrpjmlrnmlofmoaNdKGh0dHBzOi8vYXdzLmFtYXpvbi5jb20vY24va2luZXNpcy8pCioqQW1hem9uIEtpbmVzaXMgRGF0YSBTdHJlYW1zKiog5YW25a6e5ZKMZmx1bWXlvojlg48KJmVtc3A7JmVtc3A75pel5b+X6YeH6ZuG5Lyg6L6T77yMc2luawoqKkFtYXpvbiBLaW5lc2lzIERhdGEgRmlyZWhvc2UqKiDlhbblrp7lkoxrYWZrYeW+iOWDjwomZW1zcDsmZW1zcDvmtojmga/pmJ/liJfvvIzlrZjlgqgKKipBbWF6b24gS2luZXNpcyBEYXRhIEFuYWx5dGljcyoqIOWFtuWunuWSjGZsaW5r5b6I5YOPCiZlbXNwOyZlbXNwO+a1geW8j+iuoeeulw==", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 4, + "owner": "3272499474" +},{ + "_id": { + "$oid": "627367d1ce1c9f5320a2d073" + }, + "bid": "2022050513596500000000000010", + "title": "AWS Storage Gateway", + "btId": "2022050510233200000000000005", + "content": { + "$binary": { + "base64": "Kirmj5Dkvpvlh6DkuY7kuI3lj5fpmZDliLbnmoTkupHlrZjlgqjnmoTmnKzlnLDlupTnlKjnqIvluo/orr/pl67mnYPpmZAqKgpb5a6Y5pa55paH5qGjXShodHRwczovL2F3cy5hbWF6b24uY29tL2NuL3N0b3JhZ2VnYXRld2F5Lz9uYzE9aF9scyk=", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 5, + "owner": "3272499474" +},{ + "_id": { + "$oid": "6273b746ce1c9f5320a2d075" + }, + "bid": "2022050519382600000000000012", + "title": "2.1运行时数据区域", + "btId": "00000000000003", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 3, + "owner": "3272499474" +},{ + "_id": { + "$oid": "627515b3ce1c9f5320a2d078" + }, + "bid": "2022050620338300000000000015", + "title": "2.2对象内存", + "btId": "00000000000003", + "content": { + "$binary": { + "base64": "5ZyoSG90U3BvdOiZmuaLn+acuumHjO+8jOWvueixoeWcqOWghuS4reeahOWtmOWCqOW4g+WxgOWPr+S7peWIkuWIhuS4uuS4ieS4qumDqOWIhu+8muWvueixoeWktO+8iEhlYWRlcu+8ie+8jOWunuS+i+aVsOaNru+8iEluc3RhbmNlIERhdGHvvInlkozlr7npvZDloavlhYXvvIhQYWRkaW5n77yJCgojIyMjIOWvueixoeWktO+8iEhlYWRlcu+8iQotLS0K5a+56LGh5aS06YOo5YyF5ous5Lik57G75L+h5oGv77yM5LiA57G75piv55So5p2l5a2Y5YKo5a+56LGh6Ieq6Lqr55qE6L+Q6KGM5pe25pWw5o2u77yM5YyF5ousSGFzaENvZGXvvIxHQ+WIhuS7o+W5tOm+hO+8jOmUgeeKtuaAgeagh+W/l++8jOe6v+eoi+aMgeacieeahOmUge+8jOWBj+WQkee6v+eoi0lE77yM6L+Z6YeM55qE5YGP5ZCR5piv5oyHIG9mZnNldO+8jOavleern+W8leeUqOaJgOaMh+WQkeeahOWvueixoeS9jee9ruS4jeaYr+S4gOS4quWMuuWfn++8jOiAjOaYr+S4gOS4queCueOAggrov5npg6jliIbmlbDmja7plb/luqblnKgzMi82NOS4reeahOmVv+W6puS4uu+8jDTkuKrlkow45Liq5a2X6IqC77yM6KKr56ew5Li6TWFyayBXb3Jk44CCCuavlOWmguWcqDMy5L2N5LiL77yM5a+56LGh5pyq6KKr5ZCM5q2l6ZSB55qE5oOF5Ya15LiL44CCCnwg5a2Y5YKo5YaF5a65IHwgYml0IHwgc3RhdGUgfAp8IC0gfCAtIHwgLSB8CnwgSGFzaENvZGUgfCAyNSB8ICB8Cnwg5YiG5Luj5bm06b6EIHwgNCB8ICB8Cnwg5a2Y5YKo6ZSB5qCH5b+X5L2NIHwgMiB8ICB8Cnwg5Zu65a6a5Li6MCB8IDEgfCAgfAoK", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 2, + "owner": "3272499474" +},{ + "_id": { + "$oid": "6275315fce1c9f5320a2d080" + }, + "bid": "2022050622313400000000000023", + "title": "java基础面试问题1", + "btId": "2022050622313300000000000022", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 0, + "owner": "3272499474" +},{ + "_id": { + "$oid": "6275d6bfce1c9f5320a2d084" + }, + "bid": "2022050710179900000000000027", + "title": "13.1线程安全与锁优化", + "btId": "00000000000003", + "content": { + "$binary": { + "base64": "IyMgc3luY2hyb25pemVkCgogICAg5pei5Y+v5Lul55So5L2c5a+56LGh6ZSB5Lmf5Y+v5Lul55So5YGa57G76ZSBCgojIyDnsbvplIHlkozlr7nosaHplIEKCiAgICBzeW5jaHJvbml6ZWQg5a+56LGh6ZSB77yaIOavj+S4quWvueixoemDveacieS4gOS4qm1vbml0b3LvvIzogIzkuIDkuKptb25pdG9y5Y+q6IO96KKr5LiA5Liq57q/56iL5omA5oul5pyJ77yM5b2T5LiA5Liq57q/56iLYei/m+WFpW1vbml0b3JlbnRlcu+8jG1vbml0b3LnmoTov5vlhaXmlbDkuLox77yM5ZCM5pe277yM5YW25LuW55qE57q/56iL5bCx5peg5rOV6I635Y+WbW9uaXRvcu+8jOWmguaenGHlho3mrKHov5vlhaVtb25pdG9yZW50ZXLvvIxtb25pdG9y55qE6L+b5YWl5pWw5Li6Mu+8jOaJgOS7pXN5bmNocm9uaXplZCDmmK/lj6/ph43lhaXplIHjgILlvZNhIG1vbml0b3JleGl06YCA5Ye65a+56LGh6ZSB77yM5YiZbW9uaXRvcueahOi/m+WFpeaVsOWHj+WwkeS4ujHvvIzlj6rmnIltb25pdG9y55qE6L+b5YWl5pWw5Li6MOaXtuWAme+8jOWNs+ayoeacieS7u+S9lee6v+eoi+aLpeaciW1vbml0b3IKCiAgICDlr7nosaHplIEKICAgIHN5bmNocm9uaXpkZWQgbWV0aG9kICAvLyDnm7TmjqXojrflj5bor6Xmlrnms5XnmoTlr7nosaHnmoTlr7nosaHplIEKICAgIHN5bmNocm9uaXpkZWQob2JqZWN0KSB7IC8vIOiOt+WPlm9iamVjdOeahOWvueixoemUgQogICAgfQoKICAgIOexu+mUgQogICAgc3RhdGljIHN5bmNocm9uaXpkZWQgbWV0aG9kCiAgICBzeW5jaHJvbml6ZGVkKHh4eC5jbGFzcykgewogICAgfQoKICAgIC0tIOexu+mUgeWSjOWvueixoemUgeS4jeS8muS6p+eUn+ernuS6ie+8jOS6jOiAheeahOWKoOmUgeaWueazleS4jeS8muebuOS6kuW9seWTjQoKIyMg6ZSB5Zyo5ZOq77yfIGJpYXNlZCBsb2NrIOWBj+WQkemUgQoKICAgIOaIkeS7rOefpemBk2phdmHlr7nosaHmnInkuInpg6jliIbnu4TmiJAKICAgIOWvueixoeWktOmDqCBvYmplY3QgaGVhZGVyCiAgICDlrp7kvovmlbDmja4gb2JqZWN0IGRhdGEKICAgIOWvuem9kOWhq+WFhSDlkJEy55qEKm7loavlhYUKCiAgICDogIzlr7nosaHlpLTpg6jnlLFNYXJrIFdvcmTlkoxrbGFzcyBwb2ludGVy57uE5oiQCiAgICDliY045Liq5a2X6IqC5Li6TWFyayBXb3Jk77yM5ZCONOS4quWtl+iKguS4umtsYXNzIHBvaW50ZXIKICAgIOWFtuS4rU1hcmsgV29yZOmVv+W6puS4ump2beS4gOS4qndvcmTnmoTlpKflsI/jgII2NOS9jWp2beaYrzY0Yml077yM5Y2zOOS4quWtl+iKguOAggogICAgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQogICAgT0ZGU0VUICBTSVpFICBUWVBFICAgICAgICAgICAgICAgICBERVNDUklQVElPTgogICAgMCAgICAgICA0ICAgICAob2JqZWN0IGhlYWRlcikgICAgICBtYXJrd29yZAogICAgMCAgICAgICA0ICAgICAob2JqZWN0IGhlYWRlcikgICAgICBtYXJrd29yZAogICAgOCAgICAgICA0ICAgICAob2JqZWN0IGhlYWRlcikgICAgICBrbGFzcyBwb2ludGVyCiAgICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAgICBbb3BlbiBqZGsgZG9jdW1lbnRdKGh0dHA6Ly9oZy5vcGVuamRrLmphdmEubmV0L2pkazgvamRrOC9ob3RzcG90L2ZpbGUvODdlZTVlZTI3NTA5L3NyYy9zaGFyZS92bS9vb3BzL21hcmtPb3AuaHBwKQoKICAgIC8vICA2NCBiaXRzOgogICAgLy8gIC0tLS0tLS0tCiAgICAvLyAgdW51c2VkOjI1IGhhc2g6MzEgLS0+fCB1bnVzZWQ6MSAgIGFnZTo0ICAgIGJpYXNlZF9sb2NrOjEgbG9jazoyIChub3JtYWwgb2JqZWN0KQogICAgLy8gIEphdmFUaHJlYWQqOjU0IGVwb2NoOjIgdW51c2VkOjEgICBhZ2U6NCAgICBiaWFzZWRfbG9jazoxIGxvY2s6MiAoYmlhc2VkIG9iamVjdCkKICAgIC8vICBQcm9tb3RlZE9iamVjdCo6NjEgLS0tLS0tLS0tLS0tLS0tLS0tLS0tPnwgcHJvbW9fYml0czozIC0tLS0tPnwgKENNUyBwcm9tb3RlZCBvYmplY3QpCiAgICAvLyAgc2l6ZTo2NCAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLT58IChDTVMgZnJlZSBibG9jaykKICAgIC8vCiAgICAvLyAgdW51c2VkOjI1IGhhc2g6MzEgLS0+fCBjbXNfZnJlZToxIGFnZTo0ICAgIGJpYXNlZF9sb2NrOjEgbG9jazoyIChDT09QcyAmJiBub3JtYWwgb2JqZWN0KQogICAgLy8gIEphdmFUaHJlYWQqOjU0IGVwb2NoOjIgY21zX2ZyZWU6MSBhZ2U6NCAgICBiaWFzZWRfbG9jazoxIGxvY2s6MiAoQ09PUHMgJiYgYmlhc2VkIG9iamVjdCkKICAgIC8vICBuYXJyb3dPb3A6MzIgdW51c2VkOjI0IGNtc19mcmVlOjEgdW51c2VkOjQgcHJvbW9fYml0czozIC0tLS0tPnwgKENPT1BzICYmIENNUyBwcm9tb3RlZCBvYmplY3QpCiAgICAvLyAgdW51c2VkOjIxIHNpemU6MzUgLS0+fCBjbXNfZnJlZToxIHVudXNlZDo3IC0tLS0tLS0tLS0tLS0tLS0tLT58IChDT09QcyAmJiBDTVMgZnJlZSBibG9jaykKCiAgICB1bnVzZWQgICAgaGFzaCAgICB1bnVzZWQgICAgYWdlICAgIGJpYXNlZF9sb2NrICAgIGxvY2sKICAgIDI1ICAgICAtPiAzMSAgIC0+IDEgICAgICAtPiA0ICAgLT4gMSAgICAgICAgICAgLT4gMiAgICBub3JtYWwgb2JqZWN0KHN1bSA9IDY0KQoKCiAgICDml6DplIHnirbmgIHkuIvnmoRtYXJrIHdvcmQKICAgIEphdmEg5a+56LGh5Yia5Yib5bu65pe277yM6L+Y5rKh5pyJ5Lu75L2V57q/56iL5p2l56ue5LqJCiAgICB1bnVzZWQgICAgaGFzaCAgICB1bnVzZWQgICAgYWdlICAgIGJpYXNlZF9sb2NrICAgIGxvY2sKICAgIDI1ICAgICAtPiAzMSAgIC0+IDEgICAgICAtPiA0ICAgLT4gMCAgICAgICAgICAgLT4gMDEKCiAgICDlgY/lkJHnirbmgIHkuIvnmoRtYXJrIHdvcmQKICAgIOWBj+WQkemUgeaYr+aMh+S4gOauteWQjOatpeS7o+eggeS4gOebtOiiq+S4gOWQjOS4que6v+eoi+aJgOiuv+mXru+8jOmCo+S5iOivpee6v+eoi+S8muiHquWKqOiOt+WPlumUge+8jOmZjeS9juiOt+WPlumUgeeahOS7o+S7twogICAg5YGP5ZCR6ZSB5Zyo56ue5LqJ5LiN5r+A54OI55qE5oOF5Ya15LiL77yM5pWI546H6Z2e5bi46auY44CCCiAgICDnur/nqItJRCAgICBlcG9jaCAgIHVudXNlZCAgICBhZ2UgICAgYmlhc2VkX2xvY2sgICAgbG9jawogICAgNTQgICAgIC0+IDIgICAtPiAxICAgICAgIC0+IDQgICAtPiAxICAgICAgICAgICAtPiAwMQoKICAgIOi9u+mHj+e6p+mUgeeKtuaAgeS4i+eahG1hcmsgd29yZAogICAg5b2T5pyJ5Lik5Liq57q/56iL5byA5aeL56ue5LqJ6L+Z5Liq6ZSB5a+56LGh77yM6ZSB5Lya5Y2H57qn5Li66L276YeP57qn6ZSB77yM5Lik5Liq57q/56iL5YWs5bmz56ue5LqJ77yM5ZOq5Liq57q/56iL5YWI5Y2g5pyJ6ZSB5a+56LGh77yMTWFyayBXb3JkIOWwseaMh+WQkeWTquS4que6v+eoi+eahOagiOW4p+S4reeahOmUgeiusOW9lQogICAg6ZSB6K6w5b2V5oyH6ZKIICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBsb2NrCiAgICA2MiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAtPiAwMAoKICAgIOmHjemHj+e6p+mUgeeKtuaAgeeahG1hcmsgd29yZAogICAg6YeN6YeP57qn6ZSB5Lya6K6p5YW25LuW55Sz6K+355qE57q/56iL5LmL6Ze06L+b5YWl6Zi75aGe77yM5oCn6IO96ZmN5L2O44CCCiAgICDph43ph4/nuqfplIHkuZ/lsLHlj6vlgZrlkIzmraXplIHvvIzov5nkuKrplIEg5a+56LGhIE1hcmsgV29yZCDlho3mrKHlj5HnlJ/lj5jljJbvvIzkvJrmjIflkJHkuIDkuKrnm5Hop4blmajvvIhNb25pdG9y77yJ5a+56LGh77yM6K+l55uR6KeG5Zmo5a+56LGh55So6ZuG5ZCI55qE5b2iIOW8j++8jOadpeeZu+iusOWSjOeuoeeQhuaOkumYn+eahOe6v+eoi+OAggogICAgbW9uaXRvcuWvueixoeaMh+mSiCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGxvY2sKICAgIDYyICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC0+IDEwCgojIyBzeW5jaHJvbml6ZWQg55qE6ZSB5LyY5YyWCgogICAgSkRLMS425byA5aeL55qE5YeP5bCR6I635b6X6ZSB5ZKM6YeK5pS+6ZSB5bim5p2l55qE5oCn6IO95raI6ICX77yM5byV5YWl5LqG4oCc5YGP5ZCR6ZSB4oCd5ZKM4oCc6L276YeP57qn6ZSB4oCd44CCCiAgICDpnIDopoHms6jmhI/nmoTmmK/plIHlj6/ku6XljYfnuqfkvYbkuI3og73pmY3nuqcKCiMjIOWFs+S6jiBPYmplY3Qg5ZKMIFRocmVhZAoKICAgIE9iamVjdCDnsbsg5pyJbmF0aXZlIOeahCB3YWl05pa55rOVCiAgICDosIPnlKh3YWl0IOWJjSwgb2J0YWluIG1vbml0b3LvvIwKICAgIOiwg+eUqHdhaXQg5ZCO77yM6YeK5pS+5a+56LGh6ZSB77yM54S25ZCO5b2T5YmN57q/56iL6L+b5YWl562J5b6F54q25oCBd2FpdCBzZXQg6Zif5YiX5LitCgogICAgc2xlZXAoKSDkuI3ph4rmlL7plIHvvIxzbGVlcCDlj6/ku6XlnKjmsqHmnInplIHnmoTmg4XlhrXkuIvosIPnlKjvvIwK", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 8, + "owner": "3272499474" +},{ + "_id": { + "$oid": "6277d3830e877320adb04326" + }, + "bid": "2022050822283700000000000002", + "title": "31.序列化", + "btId": "2022050622313300000000000022", + "content": { + "$binary": { + "base64": "IyMjIOW6j+WIl+WMlgotLS0K5LuA5LmI5piv5bqP5YiX5YyW77yM5oCO5LmI5bqP5YiX5YyW77yM5Li65LuA5LmI5bqP5YiX5YyW77yM5Y+N5bqP5YiX5YyW5Lya6YGH5Yiw5LuA5LmI6Zeu6aKY77yM5aaC5L2V6Kej5Yaz44CCCgpkdQ==", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 1, + "owner": "3272499474" +},{ + "_id": { + "$oid": "6277ed200e877320adb04327" + }, + "bid": "2022050900177700000000000003", + "title": "反射的原理是什么", + "btId": "2022050622313300000000000022", + "content": { + "$binary": { + "base64": "5Y+N5bCE55qE5Y6f55CG77yM5Y+N5bCE5Yib5bu657G75a6e5L6L55qE5LiJ56eN5pa55byP5piv5LuA5LmICgpKdm3liqDovb3nsbvvvIjljIXmi6zmjqXlj6PvvIzms6jop6PvvIzmnprkuL7vvIzmjqXlj6PvvInkv6Hmga/ml7bvvIzkvJrlsIbor6Xkv6Hmga/ku6Xnsbvlr7nosaHvvIjljIXlkI0u57G75ZCN77yJ55qE5b2i5byP5a2Y5YKo5LqO5pa55rOV5Yy644CCCgpKYXZh5Y+N5bCE5piv5oyH77yM5ZyoSnZt6L+Q6KGM5pe277yM5a+55LqO5LiA5Liq57G777yM6YO96IO96YCa6L+H5Y+N5bCE6I635Y+W77yM6L+Z5Liq57G755qE5bGe5oCn77yM5pa55rOV77yM5p6E6YCg5Zmo562J77yM5a+55LqO5LiA5Liq5a+56LGh77yM6YCa6L+H5Y+N5bCE5Y+v5Lul6LCD55So5LuW55qE5YWo6YOo5bGe5oCn5ZKM5pa55rOV77yM6L+Z56eN5Yqo5oCB6I635Y+W55qE5L+h5oGv5Lul5Y+K5Yqo5oCB6LCD55So5a+56LGh55qE5pa55rOV55qE5Yqf6IO956ew5Li6amF2YeivreiogOeahOWPjeWwhOacuuWItuOAggoKSmF2YeWPjeWwhOS9nOS4uuWKqOaAgee8luivkeiAjOWtmOWcqO+8jOaegeWkp+eahOaPkOmrmOS6hkphdmHor63oqIDnmoTngbXmtLvmgKfjgIIKCkphdmHlj43lsITmnInkuInnp43mlrnlvI/ojrflj5bnsbvlrp7kvovvvIjkuI3mmK/lr7nosaHlrp7kvovvvInvvJoKMS5DbGFzcy5mb3JOYW1lKCks6YCa6L+H5oyH5a6a5YyF5ZCN57G75ZCN55qE5pa55byP5Zyo5pa55rOV5Yy65Y676ZyA6KaB5om+6K+l57G744CCCjIuWFhYLmNsYXNz77yMIOmAmui/h+exu+WQjS5jbGFzcyzlsYDpmZDmgKfmmK/pnZ7liqjmgIHjgIIKMy7lrp7kvovlr7nosaEuZ2V0Q2xhc3MoKeOAggoK56ys5LiA56eN57G75Yqg6L295pa55byP77yM5piv5Yqg6L295aSW6YOo57G755qE5pyA5bi455So5pa55byP44CCCuesrOS4ieenjeaWueW8j++8jOaYr+W3suefpeWvueixoeaDheWGteS4i+eahO+8jOiOt+WPluivpeexu+eahOacgOWlveaWueW8jwo=", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 2, + "owner": "3272499474" +},{ + "_id": { + "$oid": "627888170e877320adb04328" + }, + "bid": "2022050911184000000000000004", + "title": "AWS　STS", + "btId": "2022050510233200000000000005", + "content": { + "$binary": { + "base64": "CkFXUyBTZWN1cml0eSBUb2tlbiBTZXJ2aWNlIChTVFMp", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 6, + "owner": "3272499474" +},{ + "_id": { + "$oid": "627915030e877320adb0432a" + }, + "bid": "2022050921201400000000000006", + "title": "12.2关键字volatile", + "btId": "00000000000003", + "content": { + "$binary": { + "base64": "5YWz6ZSu5a2Xdm9sYXRpbGXmmK9qYXZh6Jma5ouf5py65o+Q5L6b55qE5pyA6L276YeP57qn55qE5ZCM5q2l5py65Yi244CCCuW9k+S4gOS4quWPmOmHj+iiq+WumuS5ieS4unZvbGF0aWxl5pe277yM5a6D5YW35aSH5Lik56eN54m55oCn44CCCuesrOS4gOenjeaYryoq5Y+v6KeB5oCnKirjgIIK5Y2z5q+P5qyhZ2V05pe277yM5by65Yi25Yi35paw44CCCuS4gOS4quivr+ino+WMuu+8jOWtl+iKgueggeWwseaYr+WOn+WtkOaTjeS9nO+8jOi/meaYr+S4jeWvueeahO+8jOS4gOS4quWtl+iKgueggeaMh+S7pOWcqOino+mHiuaJp+ihjOaXtu+8jOWmguaenOaYr+e8luivkeaJp+ihjO+8jOS4gOadoeWtl+iKgueggeS8muacieWPr+iDveiiq+i9rOWMluS4uuiLpeW5suS4quacrOWcsOacuuWZqOaMh+S7pOOAguatpOWkhO+8jOeUqC1YWO+8mitQcmludEFzc2VtYmx55Y+C5pWw6L6T5Ye65Y+N5rGH57yW5p2l5YiG5p6Q44CCCgrnrKzkuoznp43mmK/vvIwqKuacieW6j+aApyoq44CCCuWNs++8jOemgeatouaMh+S7pOmHjeaOkuW6j++8iEluc3RydWN0aW9uIFJlY29yZGVy77yJ5LyY5YyW44CCCuiiq3ZvbGF0aWxl5L+u6aWw55qE5Y+Y6YeP77yM6LWL5YC85ZCO5Lya5aSa5omn6KGM5LiA5LiqImxvY2sgYWRkbCLmk43kvZzvvIzov5nkuKrmk43kvZznm7jlvZPkuo7kuIDkuKptZW1vcnkgYmFycmllcu+8iOWGheWtmOWxj+manO+8ie+8jOaMh+S7pOmHjeaLjeaXtu+8jOS4jeiDveaKiuWQjumdoueahOaMh+S7pOaOkuW6j+WIsOWGheWtmOWxj+manOWJjemdouWOu++8jOWPquacieS4gOS4quWkhOeQhuWZqOiuv+mXruaXtu+8jOS4jemcgOimgeWGheWtmOWxj+manOOAggphZGRsIOaYr+S4gOS4quepuuaTjeS9nO+8jO+8iOaKikVTUOWvhOWtmOWZqOeahOWAvCArIDDvvInvvIzov5nkuKrmk43kvZznm7jlvZPkuo7miornvJPlrZjkuK3nmoTlj5jph4/lgZrkuobkuIDmrKFzdG9yZeWSjHdyaXRl5pON5L2c44CCCmxvY2sgaWRkbOaMh+S7pOaKiuS/ruaUueWQjOatpeWIsOWGheWtmOaXtu+8jOaEj+WRs+edgOaJgOacieeahOS5i+WJjeeahOaTjeS9nOmDveW3suWujOaIkO+8jOS+v+W9ouaIkOS6huaMh+S7pOmHjeaOkuW6j+aXoOazleepv+i2iuWGheWtmOWxj+manOeahOaViOaenOOAggrpkojlr7nkuo5sb25n5ZKMZG91Ymxl55qE57G75Z6L5Y+Y6YeP77yM5LiN6YCa6Jma5ouf5py65piv5pyJ552A5LiN5ZCM55qE5a6e546w77yM5q2k5aSE5LiN5YGa5o+P6L+w44CCCg==", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 5, + "owner": "3272499474" +},{ + "_id": { + "$oid": "62791d300e877320adb0432b" + }, + "bid": "2022050921544800000000000007", + "title": "12.3 原子性，可见性，有序性", + "btId": "00000000000003", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 6, + "owner": "3272499474" +},{ + "_id": { + "$oid": "62790a6b0e877320adb04329" + }, + "bid": "2022050920343900000000000005", + "title": "12.1Java内存模型和线程", + "btId": "00000000000003", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 4, + "owner": "3272499474" +},{ + "_id": { + "$oid": "627925cc0e877320adb0432c" + }, + "bid": "2022050922310000000000000008", + "title": "12.4 Happens-Before", + "btId": "00000000000003", + "content": { + "$binary": { + "base64": "IyMjIOWFiOihjOWPkeeUn+WOn+WIme+8iEhhcHBlbnMtQmVmb3Jl77yJCkphdmHlhoXlrZjmqKHlnovkuK3lpoLmnpzmiYDmnInnmoTmnInluo/mgKfpg73ku4XpnaB2b2xhdGlsZeWSjHN5bmNocm9uaXplZOadpeWujOaIkOeahOivne+8jOS8muacieW+iOWkmuaTjeS9nOWPmOW+l+WVsOWXpuOAggpKYXZh6K+t6KiA5pyJ5LiA5Liq5YWI6KGM5Y+R55Sf5Y6f5YiZ77yISGFwcGVucy1CZWZvcmXvvInjgIIK6KeE5YiZ77yaCjEu56iL5bqP5qyh5bqP6KeE5YiZCjIuTW9uaXRvciBMb2NrIFJ1bGUKMy52b2xhdGlsZSBWYXJpYWJsZSBSdWxlCjQuVGhyZWFkIFN0YXJ0IFJ1bGXvvIxzdGFydOaWueazleacgOWFiOaJp+ihjAo1LlRocmVhZCBUZXJtaW5hdGlvbiBSdWxl77yM5omA5pyJ5pa55rOV6YO95LyY5YWI5LqOCjYu57q/56iL5Lit5pat6KeE5YiZ44CCCjcu5a+56LGh57uI57uT6KeE5YiZ77yM5LiA5Liq5a+56LGh5Yid5aeL5YyW5a6M5oiQ5YWI6KGM5Y+R55Sf5LqOZmluYWxpemXvvIjvvInmlrnms5XjgIIKOC7kvKDpgJLmgKfvvIxB44CLQu+8jELjgItD77yM6YKj5LmIQeOAi0MKamludGlhbgoxMTEx", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 7, + "owner": "3272499474" +},{ + "_id": { + "$oid": "6282759a1425aa536ca456d5" + }, + "bid": "2022051700024900000000000004", + "title": "vnpy application", + "btId": "2022051700024800000000000003", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 0, + "owner": "3272499474" +},{ + "_id": { + "$oid": "628450201425aa536ca456d6" + }, + "bid": "2022051809471000000000000005", + "title": "第3章 设计与架构", + "btId": "2022051619278900000000000002", + "content": { + "$binary": { + "base64": "IyMga3ViZXJuZXRlcyDnrKwz56ugIOiuvuiuoeS4juaetuaehAojIyMgS3ViZXJuZXRlcyDorr7orqHkuI7mnrbmnoQKLS0tCuWuueWZqOWunumZheS4iuaYr+eUse+8jExpbnV4IE5hbWVzcGFjZe+8jExpbnV4IENncm91cO+8jHJvb3RmcyDov5nkuInnp43mioDmnK/mnoTlu7rlh7rmnaXnmoTjgIIK5LiN6Zq+55yL5Ye65LiA5Liq6L+Q6KGM5LitbGludXjnmoTlrrnlmajlhbblrp7lj6/ku6XooqvkuIDliIbkuLrkuoznmoTvvJoKMS7mjILovb3liLAvdmFyL2xpYi9kb2NrZXIvYXVmcy9tbnTkuIrnmoRyb290ZnPvvIzov5nkuIDpg6jliIbooqvnp7DkuLrlrrnlmajplZzlg4/vvIzmmK/lrrnlmajnmoTpnZnmgIHop4blm77jgIIKMi7kuIDkuKrnlLFOYW1lc3BhY2UrQ2dyb3Vwc+aehOaIkOeahOmalOemu+eOr+Wig++8jOi/meS4gOmDqOWIhuiiq+ensOS4uuWuueWZqOi/kOihjOaXtu+8jOaYr+WuueWZqOeahOWKqOaAgeinhuWbvuOAggrlrrnlmajnvJbmjpLpobnnm67vvJpjb21wb3NlK1N3YXJt5ZKMS3ViYXJuZXRlc+WuueWZqOe8luaOkuW3peWFt+OAggojIyMgS3ViZXJuZXRlc+eahOaguOW/g+iDveWKm+S4jumhueebruWumuS9jQotLS0KS3ViZXJuZXRlcyDnmoTmnKzotKjmmK/lubPlj7DnmoTlubPlj7DvvIzljbPkuIDkuKrnlKjmnaXluK7liqnnlKjmiLfmnoTlu7rkuIrlsYLlubPlj7DnmoTln7rnoYDlubPlj7DjgIIKUG9k5pivS3ViZXJuZXRlcyDkuK3mnIDln7rnoYDnmoTljZXlhYMK5aOw5piO5byPQVBJ5piva3ViZXJuZXRlc+acgOaguOW/g+eahOiuvuiuoeeQhuW/te+8jOmAmui/hwoKIyMjIGFwaXNlcnZlcgoKIyMjIGV0Y2QKCiMjIyBjcmkKCiMjIyBrdWJlY3RsCgojIyMga3ViZWxldAoKIyMjIHByb3h5CgojIyM=", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 1, + "owner": "3272499474" +},{ + "_id": { + "$oid": "6282353f1425aa536ca456d3" + }, + "bid": "2022051619278900000000000003", + "title": "第2章 Docker", + "btId": "2022051619278900000000000002", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 0, + "owner": "3272499474" +},{ + "_id": { + "$oid": "6284ebf31425aa536ca456d8" + }, + "bid": "2022051820523400000000000007", + "title": "Windows", + "btId": "00000000000004", + "content": { + "$binary": { + "base64": "5oiR5Lus6YCa6L+HcG93ZXJzaGVsbOWuieijheaXtu+8jOe7j+W4uOaPkOekugogICAgCuabtOaUuSBXaW5kb3dzIFBvd2VyU2hlbGwg5omn6KGM562W55Wl55qE55So5oi36aaW6YCJ6aG544CCClNldC1FeGVjdXRpb25Qb2xpY3kgCltEb2NdKGh0dHBzOi8vZG9jcy5taWNyb3NvZnQuY29tL3poLUNOL3ByZXZpb3VzLXZlcnNpb25zLy9kZDM0NzYyOCh2PXRlY2huZXQuMTApP3JlZGlyZWN0ZWRmcm9tPU1TRE4pCgpFbmFibGUtV2luZG93c09wdGlvbmFsRmVhdHVyZQpbRG9jXShodHRwczovL2RvY3MubWljcm9zb2Z0LmNvbS9lbi11cy9wb3dlcnNoZWxsL21vZHVsZS9kaXNtL2VuYWJsZS13aW5kb3dzb3B0aW9uYWxmZWF0dXJlP3ZpZXc9d2luZG93c3NlcnZlcjIwMjItcHMpCgogICAgUFMgQzpcV0lORE9XU1xzeXN0ZW0zMj4gRW5hYmxlLVdpbmRvd3NPcHRpb25hbEZlYXR1cmUgLU9ubGluZSAtRmVhdHVyZU5hbWUgTWljcm9zb2Z0LUh5cGVyLVYtVG9vbHMtQWxsCiAgICBFbmFibGUtV2luZG93c09wdGlvbmFsRmVhdHVyZSA6IOWKn+iDveWQjeensCBNaWNyb3NvZnQtSHlwZXItVi1Ub29scy1BbGwg5pyq55+l44CCCiAgICDmiYDlnKjkvY3nva4g6KGMOjEg5a2X56ymOiAxCiAgICArIEVuYWJsZS1XaW5kb3dzT3B0aW9uYWxGZWF0dXJlIC1PbmxpbmUgLUZlYXR1cmVOYW1lIE1pY3Jvc29mdC1IeXBlci1WLSAuLi4KICAgICsgICB+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn5+fn4KICAgICArIENhdGVnb3J5SW5mbyAgICAgICAgICA6IE5vdFNwZWNpZmllZDogKDopIFtFbmFibGUtV2luZG93c09wdGlvbmFsRmVhdHVyZQogICAgIF0sIENPTUV4Y2VwdGlvbgogICAgKyBGdWxseVF1YWxpZmllZEVycm9ySWQgOiAgTWljcm9zb2Z0LkRpc20uQ29tbWFuZHMuRW5hYmxlV2luZG93c09wdGlvbmFsRmVhCiAgICAgdHVyZUNvbW1hbmQ=", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 1, + "owner": "3272499474" +},{ + "_id": { + "$oid": "6284a98f1425aa536ca456d7" + }, + "bid": "2022051816085000000000000006", + "title": "Map Set List", + "btId": "00000000000002", + "content": { + "$binary": { + "base64": "IyMjIDEuIFN1bW1hcnkKCiAg5oiR5Lus5Zyo5byA5Y+R6L+H56iL5Zyo77yM5pyA5bi46KeB55qE5LiJ56eN5pWw5o2u5a2Y5YKo57uT5p6E5bCx5pivIE1hcCBTZXQg5ZKMTGlzdOS6hgoKICDov5nkuInnp43nu5PmnoTmnIDmmI7mmL7nmoTnibnlvoHlsLHmmK9NYXAg5piv6ZSu5YC877yMU2V05piv5a+56LGh5a2Y5YKo5ZSv5LiA77yMTGlzdOaYr+acieW6j+aVsOe7hAoKICAKIyMjIE1hcDxLLCBWPgogIAogIOmUruWAvOWtmOWCqO+8jOS4u+mUruS4jeWFgeiuuOmHjeWkjQoKICDmt7vliqDlhYPntKAg5L2/55SocHV05pa55rOV77yM5aaC5p6ca2V56YeN5aSN77yM5YiZdmFsdWXooqvopobnm5YKCiMjIyBTZXQ8RT4KICAKICDlr7nosaHlrZjlgqjvvIzlr7nosaHkuI3lhYHorrjph43lpI0gIAogICAgCiAgICAvKioKICAgICAqIGlmIHRoaXMgc2V0IGRpZCBub3QgYWxyZWFkeSBjb250YWluIHRoZSBzcGVjaWZpZWQgZWxlbWVudCB3aWxsIHJldHVybiB7QGNvZGUgdHJ1ZX0KICAgICAqIGYgdGhpcyBzZXQgYWxyZWFkeSBjb250YWlucyB0aGUgZWxlbWVudCwgdGhlIGNhbGwgbGVhdmVzIHRoZSBzZXQKICAgICAqIHVuY2hhbmdlZCBhbmQgcmV0dXJucyB7QGNvZGUgZmFsc2V9CiAgICAgKi8KICAgIHB1YmxpYyBib29sZWFuIGFkZChFIGUpCgojIyMgTGlzdDxFPgogIAogIGxpc3TmmK/nlLHmlbDnu4TmnoTmiJDnmoTvvIzov5nlsLHmhI/lkbPnnYDvvIxsaXN05piv5pyJ6aG65bqP55qE77yM5Zug5Li65pWw57uE5Zyo5YaF5a2Y5Lit5piv5LiA5q616L+e57ut55qE5YaF5a2Y44CC", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 10, + "owner": "3272499474" +},{ + "_id": { + "$oid": "628ae75d1425aa536ca456db" + }, + "bid": "2022052309469000000000000009", + "title": "Iot Hub Endpoint", + "btId": "2022052309468900000000000004", + "content": { + "$binary": { + "base64": "IyMjIGVuZHBvaW50cwotLS0KW0lvVCBIdWIgZW5kcG9pbnRzXShodHRwczovL2RvY3MubWljcm9zb2Z0LmNvbS9lbi11cy9henVyZS9pb3QtaHViL2lvdC1odWItZGV2Z3VpZGUtZW5kcG9pbnRzKQoKIyMgSW9UIEh1YiBuYW1lcwogICAgWW91IGNhbiBmaW5kIHRoZSBob3N0bmFtZSBvZiB0aGUgSW9UIGh1YiB0aGF0IGhvc3RzIHlvdXIgZW5kcG9pbnRzIGluIHRoZSBwb3J0YWwgb24geW91ciBodWIncyBPdmVydmlldyBwYWdlLiAKICAgIEJ5IGRlZmF1bHQsIHRoZSBETlMgbmFtZSBvZiBhbiBJb1QgaHViIGxvb2tzIGxpa2U6IHt5b3VyIGlvdCBodWIgbmFtZX0uYXp1cmUtZGV2aWNlcy5uZXQuCgojIyBMaXN0IG9mIGJ1aWx0LWluIElvVCBIdWIgZW5kcG9pbnRzCiAgICAxLiBEZXZpY2UgaWRlbnRpdHkgbWFuYWdlbWVudAogICAgMi4gRGV2aWNlIHR3aW4gbWFuYWdlbWVudAogICAgMy4gSm9icyBtYW5hZ2VtZW50CiAgICA0LiBEZXZpY2UgZW5kcG9pbnRzCiAgICA1LiBTZXJ2aWNlIGVuZHBvaW50cwogICAgNi4gUmVzb3VyY2UgcHJvdmlkZXIuCgojIyBDdXN0b20gZW5kcG9pbnRzCiAgICAxLiBBenVyZSBTdG9yYWdlIGNvbnRhaW5lcnMKICAgIDIuIEV2ZW50IEh1YnMKICAgIDMuIFNlcnZpY2UgQnVzIFF1ZXVlcwogICAgNC4gU2VydmljZSBCdXMgVG9waWNzCiAgICAKCiMjIEVuZHBvaW50IEhlYWx0aAogICAgCiMjIEZpZWxkIGdhdGV3YXlzCiAgICBJbiBhbiBJb1Qgc29sdXRpb24sIGEgZmllbGQgZ2F0ZXdheSBzaXRzIGJldHdlZW4geW91ciBkZXZpY2VzIGFuZCB5b3VyIElvVCBIdWIgZW5kcG9pbnRzLiAKICAgIEl0IGlzIHR5cGljYWxseSBsb2NhdGVkIGNsb3NlIHRvIHlvdXIgZGV2aWNlcy4KICAgIFlvdSBjYW4gdXNlIEF6dXJlIElvVCBFZGdlIHRvIGltcGxlbWVudCBhIGZpZWxkIGdhdGV3YXkuIAogICAgSW9UIEVkZ2Ugb2ZmZXJzIGZ1bmN0aW9uYWxpdHkgc3VjaCBhcyBtdWx0aXBsZXhpbmcgY29tbXVuaWNhdGlvbnMgZnJvbSBtdWx0aXBsZSBkZXZpY2VzIG9udG8gdGhlIHNhbWUgSW9UIEh1YiBjb25uZWN0aW9uLg==", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 0, + "owner": "3272499474" +},{ + "_id": { + "$oid": "628aeb311425aa536ca456dc" + }, + "bid": "2022052310025600000000000010", + "title": "Iot Hub Message routing", + "btId": "2022052309468900000000000004", + "content": { + "$binary": { + "base64": "TWVzc2FnZSByb3V0aW5nCi0tLQpbTWVzc2FnZSByb3V0aW5nXShodHRwczovL2RvY3MubWljcm9zb2Z0LmNvbS9lbi11cy9henVyZS9pb3QtaHViL2lvdC1odWItZGV2Z3VpZGUtbWVzc2FnZXMtZDJjKQoK", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 1, + "owner": "3272499474" +},{ + "_id": { + "$oid": "628b1d761425aa536ca456de" + }, + "bid": "2022052313361500000000000012", + "title": "Batch Shipyard", + "btId": "2022052309468900000000000004", + "content": { + "$binary": { + "base64": "IyMgQmF0Y2ggU2hpcHlhcmQKLS0tCltkb2NdKGh0dHBzOi8vYmF0Y2gtc2hpcHlhcmQucmVhZHRoZWRvY3MuaW8vZW4vbGF0ZXN0LzAwLWludHJvZHVjdGlvbi8pCg==", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 2, + "owner": "3272499474" +},{ + "_id": { + "$oid": "628af0dd1425aa536ca456dd" + }, + "bid": "2022052310265300000000000011", + "title": "Azure IoT Hub Device Provisioning Service (DPS)", + "btId": "2022052309468900000000000004", + "content": { + "$binary": { + "base64": "IyMjIEF6dXJlIElvVCBIdWIgRGV2aWNlIFByb3Zpc2lvbmluZyBTZXJ2aWNlIChEUFMpCi0tLQpbRFBTXShodHRwczovL2RvY3MubWljcm9zb2Z0LmNvbS9lbi11cy9henVyZS9pb3QtZHBzLz9XVC5tY19pZD1Qb3J0YWwtTWljcm9zb2Z0X0F6dXJlX0lvdEh1YikKICAgIAojIyB3aGF0IGlzIAogICAgTWljcm9zb2Z0IEF6dXJlIHByb3ZpZGVzIGEgcmljaCBzZXQgb2YgaW50ZWdyYXRlZCBwdWJsaWMgY2xvdWQgc2VydmljZXMgZm9yIGFsbCB5b3VyIElvVCBzb2x1dGlvbiBuZWVkcy4KICAgIFRoZSBJb1QgSHViIERldmljZSBQcm92aXNpb25pbmcgU2VydmljZSAoRFBTKSBpcyBhIGhlbHBlciBzZXJ2aWNlIGZvciBJb1QgSHViIHRoYXQgZW5hYmxlcyB6ZXJvLXRvdWNoLCBqdXN0LWluLXRpbWUgcHJvdmlzaW9uaW5nIHRvIHRoZSByaWdodCBJb1QgaHViIHdpdGhvdXQgcmVxdWlyaW5nIGh1bWFuIGludGVydmVudGlvbi4gCiAgICBEUFMgZW5hYmxlcyB0aGUgcHJvdmlzaW9uaW5nIG9mIG1pbGxpb25zIG9mIGRldmljZXMgaW4gYSBzZWN1cmUgYW5kIHNjYWxhYmxlIG1hbm5lci4KCiMj", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 3, + "owner": "3272499474" +},{ + "_id": { + "$oid": "628b20d91425aa536ca456df" + }, + "bid": "2022052313512900000000000013", + "title": "Azure system", + "btId": "2022052309468900000000000004", + "content": { + "$binary": { + "base64": "MS5hY3RpdmUgZGlyZWN0b3J5CjIuc3Vic2NyaXB0aW9ucwozLlJlc291cmNlIGdyb3Vwcwo0LgoKYXp1cmUg5Z+65pys5LiK5piv5Liq572R5qC85L2T57O7Cgo=", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 4, + "owner": "3272499474" +},{ + "_id": { + "$oid": "628b2c7e1425aa536ca456e1" + }, + "bid": "2022052314413800000000000015", + "title": "pricing", + "btId": "2022052309468900000000000004", + "content": { + "$binary": { + "base64": "IyMgUHJpY2luZyBPcHRpb25zCi0tLQpbZG9jXShodHRwczovL2F6dXJlLm1pY3Jvc29mdC5jb20vamEtanAvcHJpY2luZy9kZXRhaWxzL2lvdC1odWIvI3B1cmNoYXNlLW9wdGlvbnMp", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 5, + "owner": "3272499474" +},{ + "_id": { + "$oid": "628b26481425aa536ca456e0" + }, + "bid": "2022052314143400000000000014", + "title": "Java8 AQS", + "btId": "00000000000002", + "content": { + "$binary": { + "base64": "IyMgQVEKCgo=", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 11, + "owner": "3272499474" +},{ + "_id": { + "$oid": "628c4a161425aa536ca456e3" + }, + "bid": "2022052410596000000000000017", + "title": "Azure IoT Edge", + "btId": "2022052309468900000000000004", + "content": { + "$binary": { + "base64": "IyMgTW9kdWxlcwotLS0KW2RvY10oaHR0cHM6Ly9kb2NzLm1pY3Jvc29mdC5jb20vZW4tdXMvYXp1cmUvaW90LWVkZ2UvaW90LWVkZ2UtbW9kdWxlcz92aWV3PWlvdGVkZ2UtMjAyMC0xMSkKCiAgICBJb1QgRWRnZSBtb2R1bGVzIGFyZSBEb2NrZXIgY29udGFpbmVycyBkZXBsb3llZCB0byBJb1QgRWRnZSBkZXZpY2VzLgogICAgVGhleSBjYW4gY29tbXVuaWNhdGUgd2l0aCBvdGhlciBtb2R1bGVzIG9yIHNlbmQgZGF0YSB0byB0aGUgSW9UIEVkZ2UgcnVudGltZS4gCiAgICBBenVyZSBJb1QgRWRnZSBsZXRzIHlvdSBkZXBsb3kgYW5kIG1hbmFnZSBidXNpbmVzcyBsb2dpYyBvbiB0aGUgZWRnZSBpbiB0aGUgZm9ybSBvZiBtb2R1bGVzLgogICAgQXp1cmUgSW9UIEVkZ2UgbW9kdWxlcyBhcmUgdGhlIHNtYWxsZXN0IHVuaXQgb2YgY29tcHV0YXRpb24gbWFuYWdlZCBieSBJb1QgRWRnZSwgYW5kIGNhbiBjb250YWluIEF6dXJlIHNlcnZpY2VzIChzdWNoIGFzIEF6dXJlIFN0cmVhbSBBbmFseXRpY3MpIG9yIHlvdXIgb3duIHNvbHV0aW9uLXNwZWNpZmljIGNvZGUuIAogICAgVG8gdW5kZXJzdGFuZCBob3cgbW9kdWxlcyBhcmUgZGV2ZWxvcGVkLCBkZXBsb3llZCwgYW5kIG1haW50YWluZWQsIGNvbnNpZGVyIHRoZSBmb3VyIGNvbmNlcHR1YWwgZWxlbWVudHMgb2YgYSBtb2R1bGU6CgojIyBSb3V0ZXMKLS0tCltkb2NdKGh0dHBzOi8vZG9jcy5taWNyb3NvZnQuY29tL2phLWpwL2F6dXJlL2lvdC1lZGdlL21vZHVsZS1jb21wb3NpdGlvbj92aWV3PWlvdGVkZ2UtMjAyMC0xMSNkZWNsYXJlLXJvdXRlcykKCgojIyBJb1QgRWRnZSBkZXBsb3ltZW50cwotLS0KW2RvY10oaHR0cHM6Ly9kb2NzLm1pY3Jvc29mdC5jb20vamEtanAvYXp1cmUvaW90LWVkZ2UvbW9kdWxlLWRlcGxveW1lbnQtbW9uaXRvcmluZz92aWV3PWlvdGVkZ2UtMjAyMC0xMSkKCiAgICBJb1QgRWRnZSBkZXBsb3ltZW50cyBjb25maWd1cmUgc2V0cyBvZiBJb1QgRWRnZSBkZXZpY2VzIHRvIHJ1biBJb1QgRWRnZSBtb2R1bGVzLiAKICAgIEVhY2ggZGVwbG95bWVudCBjb250aW51b3VzbHkgZW5zdXJlcyB0aGF0IGFsbCBtYXRjaGluZyBkZXZpY2VzIGFyZSBydW5uaW5nIHRoZSBzcGVjaWZpZWQgc2V0IG9mIG1vZHVsZXMsIGV2ZW4gd2hlbiBuZXcgZGV2aWNlcyBhcmUgY3JlYXRlZCBvciBhcmUgbW9kaWZpZWQgdG8gbWF0Y2ggdGhlIHRhcmdldCBjb25kaXRpb24uCgogICAgVHdvIG1vZHVsZXMgYXJlIHJlcXVpcmVkIGluIGV2ZXJ5IGRlcGxveW1lbnQgbWFuaWZlc3Q6ICRlZGdlQWdlbnQsIGFuZCAkZWRnZUh1Yi4gCgogICAgVGhlc2UgbW9kdWxlcyBhcmUgcGFydCBvZiB0aGUgSW9UIEVkZ2UgcnVudGltZSB0aGF0IG1hbmFnZXMgdGhlIElvVCBFZGdlIGRldmljZSBhbmQgdGhlIG1vZHVsZXMgcnVubmluZyBvbiBpdC4gIAo=", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 6, + "owner": "3272499474" +},{ + "_id": { + "$oid": "62958b4c1425aa536ca456e4" + }, + "bid": "2022053111285300000000000018", + "title": "kubernetes etcd安装", + "btId": "2022051619278900000000000002", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 9, + "owner": "3272499474" +},{ + "_id": { + "$oid": "629f13be1425aa536ca456e7" + }, + "bid": "2022060717000500000000000021", + "title": "第5章 编排原理", + "btId": "2022051619278900000000000002", + "content": { + "$binary": { + "base64": "IyMga3ViZXJuZXRlcyDnrKw156ugIOe8luaOkuWOn+eQhgojIyMg5rGh54K5Ci0tLQpgdGFpbnRz77ya5rGh54K577yM5a6a5LmJ5Zyo6IqC54K55LiK77yM5piv6ZSu5YC85pWw5o2uYApgdG9sZXJhdGlvbnPvvJrlrrnlv43luqbvvIzlrprkuYnlnKhwb2TkuIrvvIzlj6/ku6XlrprkuYnog73lrrnlv43lk6rkupvmsaHngrlgCgogICAgCiAgICB0YWludHM6CiAgICAtIGVmZmVjdDogTm9TY2hlZHVsZSDkuI3kvJrooqvosIPluqYKICAgICAga2V5OiBub2RlLXJvbGUua3ViZXJuZXRlcy5pby9tYXN0ZXIKICAgIC0gZWZmZWN0OiBQcmVmZXJOb1NjaGVkdWxlIOWwvemHj+S4jeiwg+W6pgogICAgICBrZXk6IG5vZGUtcm9sZS5rdWJlcm5ldGVzLmlvL21hc3RlcgogICAgLSBlZmZlY3Q6IE5vRXhlY3V0ZSDpqbHpgJDoioLngrkgCiAgICAgIGtleTogbm9kZS1yb2xlLmt1YmVybmV0ZXMuaW8vbWFzdGVyCgogICAgdG9sZXJhdGlvbnM6CiAgICAtIGtleTogImtleSIKICAgICAgb3BlcmF0b3I6ICJFcXVhbCIKICAgICAgdmFsdWU6ICJ2YWx1ZSIKICAgICAgZWZmZWN0OiAiTm9TY2hlZHVsZSIKCiAgICB0b2xlcmF0aW9uczoKICAgIC0ga2V5OiAia2V5IgogICAgICBvcGVyYXRvcjogIkV4aXN0cyIKICAgICAgZWZmZWN0OiAiTm9TY2hlZHVsZSIKCiAgICDkuIDkuKogdG9sZXJhdGlvbuWSjOS4gOS4qiB0YWludCDnm7gi5Yy56YWNIuaYr+aMh+Wug+S7rOacieS4gOagt+eahGtleeWSjGVmZmVjdAogICAgb3BlcmF0b3Ig6buY6K6k5pivIEVxdWFsIO+8jOWNs3ZhbHVlIOebuOetieaJjeWMuemFjQoKYG1hc3RlcuiKgueCuem7mOiupOaYr+acieaxoeeCueeahOWPr+S7pemAmui/h+S7peS4i+WRveS7pOafpeeci2AKICAKICAgIGt1YmVjdGwgZGVzY3JpYmUgbm9kZXMgbm9kZTEgfCBncmVwIFRhaW50cwogICAgVGFpbnRzOiAgICAgICAgICAgICBub2RlLXJvbGUua3ViZXJuZXRlcy5pby9tYXN0ZXI6Tm9TY2hlZHVsZQogICAg6K+l5rGh54K56KGo56S677yM5LiN5Lya6KKr6LCD5bqm44CCCgogICAga3ViZWN0bCBkZXNjcmliZSBub2RlcyBub2RlMiB8IGdyZXAgVGFpbnRzCiAgICBUYWludHM6ICAgICAgICAgICAgIDxub25lPgoKYOWmguS9leWcqG1hc3RlcuiKgueCueWPkeW4g3BvZOWRomAKICAgIAo=", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 3, + "owner": "3272499474" +},{ + "_id": { + "$oid": "629d8ad11425aa536ca456e5" + }, + "bid": "2022060613040400000000000019", + "title": "第4章 kubeadm", + "btId": "2022051619278900000000000002", + "content": { + "$binary": { + "base64": "## kubernetes 第4章 kubeadm
### k8s 安装相关 doc
---
[apiDoc](https://kubernetes.io/docs/reference/config-api/)  
[docker centos install doc](https://docs.docker.com/engine/install/centos/)

## 4.1 安装背景
---
腾讯云服务器，3台2G四核的不同网段的轻量云服务器（特价买的）。
因为轻量云服务器采用的是VPC网络，所以通过ip addr 命令可以看到并没有公网网址。
和一个网段私有网络不同，这里是需要公网ip的，所以做了一个临时的虚拟网卡：

`4.1.1` 创建临时网卡先应付：
    
    # 每台机器都要做(临时网卡做法，永久性的暂时没测试)
    ifconfig eth0:1 49.233.4.79 netmask 255.255.255.0 up
    ifconfig eth0:1 43.138.55.43 netmask 255.255.255.0 up
    ifconfig eth0:1 43.138.73.106 netmask 255.255.255.0 up

`4.1.2` 腾讯云有两个网络访问安全的设置：
    
    # 添加 安全组 规则 放行所有6443 TCP端口
    # 防火前 添加 规则 ，放行 node1 node2 node3 的6443 TCP网络

`4.1.3` hostname修改
    
    # hostname 修改
    hostnamectl set-hostname xx

`4.1.4` 设置3台机器的网络连接：
    
    # 修改 /etc/hosts
    vi /etc/hosts
    
    # 将以下内容添加即可
    49.233.4.79 node1
    43.138.55.43 node2
    43.138.73.106 node3

    # ping 
    ping node3 

`4.1.5` 将 SELinux 设置为 permissive 模式（相当于将其禁用）

    sudo setenforce 0
    sudo sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config

`4.1.6` 关闭swap

    swapoff -a  
    sed -ri 's/.*swap.*/#&/' /etc/fstab

`4.1.7` 允许 iptables 检查桥接流量

    cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
    br_netfilter
    EOF

    cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
    net.bridge.bridge-nf-call-ip6tables = 1
    net.bridge.bridge-nf-call-iptables = 1
    EOF
    
    sysctl --system

`4.1.8` 删除以前残留的网络设置信息

    rm -rf /etc/cni/net.d/*
    rm -rf /var/lib/cni/calico
    systemctl  restart kubelet

    systemctl stop kubelet
    systemctl stop docker
    rm -rf /var/lib/cni/
    rm -rf /var/lib/kubelet/*
    rm -rf /etc/cni/
    ifconfig cni0 down
    ifconfig flannel.1 down
    ifconfig docker0 down
    iptb
    ip link delete cni0
    ip link delete flannel.1
    systemctl start docker
    systemctl start kubelet

### 4.2 kubeadm install
---
记录一次使用kubeadm安装的操作。
kubeadm：直接在宿主机上运行kubelet，然后使用容器部署其他k8s组件的妥协方式。

`4.2.1` docker install
Preflight check
拿到云服务器(centos 7.6)后，首先安装了docker

    49.233.4.79
    2705483506 43.138.55.43
    3584667696 43.138.73.106

    
    # 查看docker-ce的版本
    yum list docker-ce --showduplicates | sort -r
    # 安装docker
    # yum install docker-ce-<VERSION_STRING> docker-ce-cli-<VERSION_STRING> containerd.io docker-compose-plugin
    yum install docker-ce-20.10.17-3.el7 docker-ce-cli-20.10.17-3.el7 containerd.io docker-compose-plugin

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

`4.2.2` kubelet/kubectl/kubeadm download

    # 指定版本号最好
    yum -y install kubelet-1.23.7-0 kubeadm-1.23.7-0 kubectl-1.23.7-0
    # 如果原来存在多个版本，请删除,因为默认是使用高版本的，会导致无法加入node
    yum -y remove kubeadm* kubelet* kubectl*

    systemctl enable kubelet.service

    # 修改 docker 的cgroup
    # 添加以下内容
    vim /etc/docker/daemon.json
    {
      "exec-opts": ["native.cgroupdriver=systemd"]
    }
    # 重启docker
    systemctl restart docker
    docker info | grep Cgroup  


### 4.3 kubeadm init

    # 创建集群，其他默认就可以，需要指定集群公网地址和CIDR局域网网段
    kubeadm init --apiserver-advertise-address 49.233.4.79 --pod-network-cidr=10.244.0.0/16

    # 使集群生效，
    mkdir -p $HOME/.kube
    sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
    sudo chown $(id -u):$(id -g) $HOME/.kube/config
    
    # token 24h 过期
    kubeadm token create --print-join-command
    # 查看集群master节点
    kubectl describe node node1

    # 查看集群pods，我们会发现，coredns 一直处于Pending状态，这是符合预期的，因为我们还没有安装集群插件
    kubectl get pods -A

    # 安装集群插件 flannel
    # https://github.com/flannel-io/flannel/blob/master/Documentation/kube-flannel.yml
    kubectl apply -f kube-flannel.yaml

    # 安装集群网络插件 
    kubectl apply -f https://docs.projectcalico.org/manifests/calico.yaml

    # 再查看集群pods，一定要先安装网络插件，再去添加集群节点哦。
    kubectl get pods -A

    # 加入worker节点
    # 由于不在一个内网，集群间通讯默认走内网ip，因此需要借助公网ip，通过iptables转换
    iptables -t nat -A OUTPUT -d  -j DNAT --to-destination 青云内网ip


    # 然后 kubeadm join 在其他node处添加进来。
    kubeadm join 49.233.4.79:6443 --token xx.xxx \
        --discovery-token-ca-cert-hash sha256:xxxxxxx

    # 到这一步集群节点就算完事了。

### 4.4 ETCD
---

`4.4.1` etcd ca 

    # etcd 作为数据库 也有自己的ca，kubeadm 安装etcd时ca是存入以下路径
    /etc/kubernetes/pki/etcd/
 
`4.4.2` etcd comman

    1. 查看ETCD集群中运行的ETCD pod
    kubectl get pod -n kube-system | grep etcd
    2. 进入ETCD pod容器
    kubectl exec -it etcd-node1 -n kube-system -- /bin/sh
    3. 设置环境变量为v3
    export ETCDCTL_API=3
    4. 查看 member list
    ETCDCTL_API=3 etcdctl \
    --cacert=/etc/kubernetes/pki/etcd/ca.crt \
    --cert=/etc/kubernetes/pki/etcd/healthcheck-client.crt \
    --key=/etc/kubernetes/pki/etcd/healthcheck-client.key \ 
    member list
    check perf
    4. 查看 key 需要加上cert才可以
    etcdctl get /registry/pods/kube-system/kube-flannel-ds-vnhrw
    5. 未查询简单化，添加别名
    # 别名列表
    alias -p
    # 添加别名
    alias cls=clear
    # 删除别名
    unalias 别名
    alias etc="/usr/local/bin/etcdctl --endpoints=https://127.0.0.1:2379 --cacert=/etc/kubernetes/pki/etcd/ca.crt --cert=/etc/kubernetes/pki/etcd/server.crt --key=/etc/kubernetes/pki/etcd/server.key"
    6. 查询所有的key
    etcdctl get / --prefix --keys-only
    7. 查询flnanel配置
    etcdctl get /registry/configmaps/kube-system/kube-flannel-cfg
    ETCD_ENABLE_V2=true 
    ETCDCTL_API=2 etcdctl ls /coreos.com/network/subnets/
    ETCDCTL_API=2 etcdctl cluster-health
    ETCDCTL_API=2 etcdctl member list
    ETCDCTL_API=3 etcdctl member list
    ETCDCTL_API=3 etcdctl check perf

### 4.5 各种错误的解决方法。
---    
    # 最典型的就是版本不统一导致的安装错误

    [ERROR CRI]: container runtime is not running: output: time="2022-06-13T10:26:24+08:00" level=fatal msg="unable to determine runtime API version: rpc error: code = Unavailable desc = connection error: desc = \"transport: Error while dialing dial unix /var/run/containerd/containerd.sock: connect: no such file or directory\""
详细过程如下：

这个原因吧 是一开始 直接yum -y install docker 发生的错，后来用docker-ce 就直接修复了

     [ERROR KubeletVersion]: the kubelet version is higher than the control plane version. This is not a supported version skew and may lead to a malfunctional cluster. Kubelet version: "1.24.1" Control plane version: "1.23.7"
    yum -y remove kubelet
    yum -y install kubelet-1.23.7 kubeadm-1.23.7

kubeadm init 时候会发现被墙了。
    
    I0613 12:39:59.679221   18038 checks.go:859] pulling: k8s.gcr.io/coredns/coredns:v1.8.6
    [preflight] Some fatal errors occurred:
        [ERROR ImagePull]: failed to pull image k8s.gcr.io/kube-apiserver:v1.23.7: output: Error response from daemon: Get "https://k8s.gcr.io/v2/": net/http: request canceled while waiting for connection (Client.Timeout exceeded while awaiting headers)
解决方案： https://www.cnblogs.com/lifan1998/p/14326761.html
DOCKERHUB_URL=registry.aliyuncs.com/google_containers
---
kubeadm init 时候kubelet check 出错

    [kubelet-check] It seems like the kubelet isn't running or healthy.
    [kubelet-check] The HTTP call equal to 'curl -sSL http://localhost:10248/healthz' failed with error: Get "http://localhost:10248/healthz": dial tcp [::1]:10248: connect: connection refused.

使用 journalctl -xeu kubelet查看错误信息，基本上是docker 的cgroup和k8s的cgroup不一致导致的。
修改 docker 的cgroup

    解决方法
    # 添加以下内容
    vim /etc/docker/daemon.json
    {
      "exec-opts": ["native.cgroupdriver=systemd"]
    }

    # 重启docker
    systemctl restart docker
    docker info | grep Cgroup
    # 重新初始化
    kubeadm reset # 先重置


### 上述master节点完成后进入，worker node安装
---

    # 确保和主节点的kubeadm版本相同
    yum list --showduplicates kubeadm
    yum -y install kubeadm-1.23.7-0 kubelet-1.23.7-0 kubectl-1.23.7-0
    systemctl enable kubelet.service

### /proc/sys/net/bridge/bridge-nf-call-iptables contents are not set to 1
错误

    [ERROR FileContent–proc-sys-net-bridge-bridge-nf-call-iptables]: /proc/sys/net/bridge/bridge-nf-call-iptables contents are not set to 1
    [preflight] If you know what you are doing, you can make a check non-fatal with --ignore-preflight-errors=...

解决方案

    echo “1” >/proc/sys/net/bridge/bridge-nf-call-iptables




", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 2, + "owner": "3272499474" +},{ + "_id": { + "$oid": "62a00fb61425aa536ca456e8" + }, + "bid": "2022060810550500000000000022", + "title": "Java8 Stream", + "btId": "00000000000002", + "content": { + "$binary": { + "base64": "IyMgUwoK", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 12, + "owner": "3272499474" +},{ + "_id": { + "$oid": "62a044961425aa536ca456e9" + }, + "bid": "2022060814418900000000000023", + "title": "第6章 存储原理", + "btId": "2022051619278900000000000002", + "content": { + "$binary": { + "base64": "a3ViZXJuZXRlcyDnrKw256ugIOWtmOWCqOWOn+eQhg==", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 4, + "owner": "3272499474" +},{ + "_id": { + "$oid": "62a044ab1425aa536ca456ea" + }, + "bid": "2022060814410000000000000024", + "title": "第7章 网络原理", + "btId": "2022051619278900000000000002", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 5, + "owner": "3272499474" +},{ + "_id": { + "$oid": "62a044c51425aa536ca456eb" + }, + "bid": "2022060814420100000000000025", + "title": "第8章 调度与资源管理", + "btId": "2022051619278900000000000002", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 6, + "owner": "3272499474" +},{ + "_id": { + "$oid": "62a98f641425aa536ca456ee" + }, + "bid": "2022061515517700000000000028", + "title": "第10章 资源", + "btId": "2022051619278900000000000002", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 7, + "owner": "3272499474" +},{ + "_id": { + "$oid": "62abec208dc619013bbe0dbb" + }, + "bid": "2022061710512100000000000001", + "title": "第11章 权限控制", + "btId": "2022051619278900000000000002", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 8, + "owner": "3272499474" +},{ + "_id": { + "$oid": "62b458a501b8955772b6db9f" + }, + "bid": "2022062320127000000000000005", + "title": "基于虚拟网卡共有网络k8s集群搭建", + "btId": "2022051619278900000000000002", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 10, + "owner": "3272499474" +},{ + "_id": { + "$oid": "62c05f4d01b8955772b6dba1" + }, + "bid": "2022070223079600000000000007", + "title": "kubernetes Calico 配置", + "btId": "2022051619278900000000000002", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 11, + "owner": "3272499474" +},{ + "_id": { + "$oid": "62c13cb201b8955772b6dba2" + }, + "bid": "2022070314528700000000000008", + "title": "kubernetes 二进制安装worker", + "btId": "2022051619278900000000000002", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 13, + "owner": "3272499474" +},{ + "_id": { + "$oid": "62beace701b8955772b6dba0" + }, + "bid": "2022070116141100000000000006", + "title": "kubernetes 二进制安装master", + "btId": "2022051619278900000000000002", + "content": { + "$binary": { + "base64": "### 事前准备
---

如果以前有安装过， 请清理掉

    ll /usr/lib/systemd/system/kube*

    systemctl stop kube-apiserver
    systemctl stop kube-controller-manager
    systemctl stop kubelet
    systemctl stop kube-proxy
    systemctl stop kube-scheduler


    目录准备
    mkdir -p /usr/local/kubernetes/{bin,conf,ssl,logs} 
    
### kube-apiserver 安装
---

`生成自签CA配置`

    cat > ca-config.json << EOF
    {
      "signing": {
        "default": {
          "expiry": "87600h"
        },
        "profiles": {
          "kubernetes": {
             "expiry": "87600h",
             "usages": [
                "signing",
                "key encipherment",
                "server auth",
                "client auth"
            ]
          }
        }
      }
    }
    EOF

    cat > ca-csr.json << EOF
    {
        "CN": "kubernetes CA",
        "key": {
            "algo": "rsa",
            "size": 2048
        },
        "names": [
            {
                "C": "CN",
                "L": "ShangHai",
                "ST": "ShangHai",
                "O": "k8s",
                "OU": "system"
            }
        ]
    }
    EOF
    
    生成CA
    cfssl gencert -initca ca-csr.json | cfssljson -bare ca -
---

`给apiServer签发证书`

    cat > server-csr.json << EOF
    {
        "CN": "kubernetes",
        "hosts": [
    	  "10.244.0.1",
          "10.0.0.1",
          "127.0.0.1",
          "49.233.4.79",
          "43.138.55.43",
          "43.138.73.106",
          "10.0.16.3",
          "10.0.8.13",
          "kubernetes",
          "kubernetes.default",
          "kubernetes.default.svc",
          "kubernetes.default.svc.cluster",
          "kubernetes.default.svc.cluster.local"
        ],
        "key": {
            "algo": "rsa",
            "size": 2048
        },
        "names": [
            {
                "C": "CN",
                "L": "ShangHai",
                "ST": "ShangHai",
                "O": "k8s",
                "OU": "system"
            }
        ]
    }
    EOF

    cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes server-csr.json | cfssljson -bare server


    生成token
    head -c 16 /dev/urandom | od -An -t x | tr -d ' '
    cat > /usr/local/kubernetes/conf/token.csv << EOF
    f41424f202b2c2e71da40ce20d32f1d2,kubelet-bootstrap,10001,"system:node-bootstrapper"
    EOF
---

    cat > /usr/lib/systemd/system/kube-apiserver.service << EOF
    [Unit]
    Description=Kubernetes API Server
    Documentation=https://github.com/kubernetes/kubernetes
    
    [Service]
    EnvironmentFile=/usr/local/kubernetes/conf/kube-apiserver.conf
    ExecStart=/usr/local/kubernetes/bin/kube-apiserver \$KUBE_APISERVER_OPTS
    Restart=on-failure
    
    [Install]
    WantedBy=multi-user.target
    EOF
---
    
    vi kube-apiserver.conf

    KUBE_APISERVER_OPTS="--logtostderr=false \
    --v=2 \
    --log-dir=/usr/local/kubernetes/logs \
    --etcd-servers=https://49.233.4.79:2379,https://43.138.55.43:2379,https://43.138.73.106:2379 \
    --bind-address=49.233.4.79 \
    --secure-port=6443 \
    --advertise-address=49.233.4.79 \
    --allow-privileged=true \
    --service-cluster-ip-range=10.0.0.0/16 \
    --enable-admission-plugins=NamespaceLifecycle,LimitRanger,ServiceAccount,ResourceQuota,NodeRestriction \
    --authorization-mode=RBAC,Node \
    --enable-bootstrap-token-auth=true \
    --token-auth-file=/usr/local/kubernetes/conf/token.csv \
    --service-node-port-range=30000-32767 \
    --kubelet-client-certificate=/usr/local/kubernetes/ssl/server.pem \
    --kubelet-client-key=/usr/local/kubernetes/ssl/server-key.pem \
    --tls-cert-file=/usr/local/kubernetes/ssl/server.pem  \
    --tls-private-key-file=/usr/local/kubernetes/ssl/server-key.pem \
    --client-ca-file=/usr/local/kubernetes/ssl/ca.pem \
    --service-account-key-file=/usr/local/kubernetes/ssl/ca-key.pem \
    --service-account-issuer=api \
    --service-account-signing-key-file=/usr/local/kubernetes/ssl/server-key.pem \
    --etcd-cafile=/usr/local/etcd-v3.5.0/ssl/ca.pem \
    --etcd-certfile=/usr/local/etcd-v3.5.0/ssl/server.pem \
    --etcd-keyfile=/usr/local/etcd-v3.5.0/ssl/server-key.pem \
    --requestheader-client-ca-file=/usr/local/kubernetes/ssl/ca.pem \
    --proxy-client-cert-file=/usr/local/kubernetes/ssl/server.pem \
    --proxy-client-key-file=/usr/local/kubernetes/ssl/server-key.pem \
    --requestheader-allowed-names=kubernetes \
    --requestheader-extra-headers-prefix=X-Remote-Extra- \
    --requestheader-group-headers=X-Remote-Group \
    --requestheader-username-headers=X-Remote-User \
    --enable-aggregator-routing=true \
    --audit-log-maxage=30 \
    --audit-log-maxbackup=3 \
    --audit-log-maxsize=100 \
    --audit-log-path=/usr/local/kubernetes/logs/k8s-audit.log"

---
    
    # 刷新设置，并设置开机启动，查看status
    systemctl daemon-reload
    systemctl start kube-apiserver 
    systemctl enable kube-apiserver
    systemctl status kube-apiserver -l

    
### kube-controller-manager 安装
---
`创建配置文件`

    cat > /usr/local/kubernetes/conf/kube-controller-manager.conf << EOF
    KUBE_CONTROLLER_MANAGER_OPTS="--logtostderr=false \\
    --v=2 \\
    --log-dir=/usr/local/kubernetes/logs \\
    --leader-elect=true \\
    --kubeconfig=/usr/local/kubernetes/conf/kube-controller-manager.kubeconfig \\
    --bind-address=127.0.0.1 \\
    --allocate-node-cidrs=true \\
    --cluster-cidr=10.244.0.0/16 \\
    --service-cluster-ip-range=10.0.0.0/16 \\
    --cluster-signing-cert-file=/usr/local/kubernetes/ssl/ca.pem \\
    --cluster-signing-key-file=/usr/local/kubernetes/ssl/ca-key.pem  \\
    --root-ca-file=/usr/local/kubernetes/ssl/ca.pem \\
    --service-account-private-key-file=/usr/local/kubernetes/ssl/ca-key.pem \\
    --cluster-signing-duration=87600h0m0s"
    EOF


---
`生成证书`

    cd /usr/local/kubernetes/ssl
    cat > kube-controller-manager-csr.json << EOF
    {
      "CN": "system:kube-controller-manager",
      "hosts": [],
      "key": {
        "algo": "rsa",
        "size": 2048
      },
      "names": [
        {
          "C": "CN",
          "L": "ShangHai", 
          "ST": "ShangHai",
          "O": "system:masters",
          "OU": "System"
        }
      ]
    }
    EOF

    cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-controller-manager-csr.json | cfssljson -bare kube-controller-manager

    ll

`生成kubeconfig文件`

    KUBE_CONFIG="/usr/local/kubernetes/conf/kube-controller-manager.kubeconfig"
    KUBE_APISERVER="https://49.233.4.79:6443"
    
    kubectl config set-cluster kubernetes \
      --certificate-authority=/usr/local/kubernetes/ssl/ca.pem \
      --embed-certs=true \
      --server=${KUBE_APISERVER} \
      --kubeconfig=${KUBE_CONFIG}
      
    kubectl config set-credentials kube-controller-manager \
      --client-certificate=/usr/local/kubernetes/ssl/kube-controller-manager.pem \
      --client-key=/usr/local/kubernetes/ssl/kube-controller-manager-key.pem \
      --embed-certs=true \
      --kubeconfig=${KUBE_CONFIG}
      
    kubectl config set-context default \
      --cluster=kubernetes \
      --user=kube-controller-manager \
      --kubeconfig=${KUBE_CONFIG}
      
    kubectl config use-context default --kubeconfig=${KUBE_CONFIG}
    
    ll /usr/local/kubernetes/conf
---

`systemd管理controller-manager`

    cat > /usr/lib/systemd/system/kube-controller-manager.service << EOF
    [Unit]
    Description=Kubernetes Controller Manager
    Documentation=https://github.com/kubernetes/kubernetes
    
    [Service]
    EnvironmentFile=/usr/local/kubernetes/conf/kube-controller-manager.conf
    ExecStart=/usr/local/kubernetes/bin/kube-controller-manager \$KUBE_CONTROLLER_MANAGER_OPTS
    Restart=on-failure
    
    [Install]
    WantedBy=multi-user.target
    EOF
---
`启动并设置开机自启`

    systemctl daemon-reload
    systemctl start kube-controller-manager
    systemctl enable kube-controller-manager
    systemctl status kube-controller-manager -l



### kube-scheduler 安装
---
`创建配置文件`

    cat > /usr/local/kubernetes/conf/kube-scheduler.conf << EOF
    KUBE_SCHEDULER_OPTS="--logtostderr=false \\
    --v=2 \\
    --log-dir=/usr/local/kubernetes/logs \\
    --leader-elect \\
    --kubeconfig=/usr/local/kubernetes/conf/kube-scheduler.kubeconfig \\
    --bind-address=127.0.0.1"
    EOF
---
`生成kubeconfig文件`

    cd /usr/local/kubernetes/ssl
    
    cat > kube-scheduler-csr.json << EOF
    {
      "CN": "system:kube-scheduler",
      "hosts": [],
      "key": {
        "algo": "rsa",
        "size": 2048
      },
      "names": [
        {
          "C": "CN",
          "L": "ShangHai",
          "ST": "ShangHai",
          "O": "system:masters",
          "OU": "System"
        }
      ]
    }
    EOF
    
    cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-scheduler-csr.json | cfssljson -bare kube-scheduler

    ll
---
`生成kubeconfig文件 `    

    KUBE_CONFIG="/usr/local/kubernetes/conf/kube-scheduler.kubeconfig"
    KUBE_APISERVER="https://49.233.4.79:6443"
    
    kubectl config set-cluster kubernetes \
      --certificate-authority=/usr/local/kubernetes/ssl/ca.pem \
      --embed-certs=true \
      --server=${KUBE_APISERVER} \
      --kubeconfig=${KUBE_CONFIG}
      
    kubectl config set-credentials kube-scheduler \
      --client-certificate=/usr/local/kubernetes/ssl/kube-scheduler.pem \
      --client-key=/usr/local/kubernetes/ssl/kube-scheduler-key.pem \
      --embed-certs=true \
      --kubeconfig=${KUBE_CONFIG}
      
    kubectl config set-context default \
      --cluster=kubernetes \
      --user=kube-scheduler \
      --kubeconfig=${KUBE_CONFIG}
      
    kubectl config use-context default --kubeconfig=${KUBE_CONFIG}

---
`systemd管理scheduler`

    cat > /usr/lib/systemd/system/kube-scheduler.service << EOF
    [Unit]
    Description=Kubernetes Scheduler
    Documentation=https://github.com/kubernetes/kubernetes
    
    [Service]
    EnvironmentFile=/usr/local/kubernetes/conf/kube-scheduler.conf
    ExecStart=/usr/local/kubernetes/bin/kube-scheduler \$KUBE_SCHEDULER_OPTS
    Restart=on-failure
    
    [Install]
    WantedBy=multi-user.target
    EOF

---
`启动并设置开机启动`

    systemctl daemon-reload
    systemctl start kube-scheduler
    systemctl enable kube-scheduler
    systemctl status kube-scheduler -l

---

### kubectl 安装
---

`生成kubectl连接集群的证书`

    cd /usr/local/kubernetes/ssl
    cat > admin-csr.json <<EOF
    {
      "CN": "admin",
      "hosts": [],
      "key": {
        "algo": "rsa",
        "size": 2048
      },
      "names": [
        {
          "C": "CN",
          "L": "ShangHai",
          "ST": "ShangHai",
          "O": "system:masters",
          "OU": "System"
        }
      ]
    }
    EOF

    cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes admin-csr.json | cfssljson -bare admin
    ll
---
`生成kubeconfig文件`

    rm -rf /root/.kube
    mkdir /root/.kube
    
    KUBE_CONFIG="/root/.kube/config"
    KUBE_APISERVER="https://49.233.4.79:6443"
    
    kubectl config set-cluster kubernetes \
      --certificate-authority=/usr/local/kubernetes/ssl/ca.pem \
      --embed-certs=true \
      --server=${KUBE_APISERVER} \
      --kubeconfig=${KUBE_CONFIG}
      
    kubectl config set-credentials cluster-admin \
      --client-certificate=/usr/local/kubernetes/ssl/admin.pem \
      --client-key=/usr/local/kubernetes/ssl/admin-key.pem \
      --embed-certs=true \
      --kubeconfig=${KUBE_CONFIG}
      
    kubectl config set-context default \
      --cluster=kubernetes \
      --user=cluster-admin \
      --kubeconfig=${KUBE_CONFIG}
      
    kubectl config use-context default --kubeconfig=${KUBE_CONFIG}

    ll

---
`通过kubectl工具查看当前集群组件状态`

    [root@k8s-master1 ssl]# kubectl get cs
    Warning: v1 ComponentStatus is deprecated in v1.19+
    NAME                 STATUS    MESSAGE                         ERROR
    scheduler            Healthy   ok
    controller-manager   Healthy   ok
    etcd-2               Healthy   {"health":"true","reason":""}
    etcd-0               Healthy   {"health":"true","reason":""}
    etcd-1               Healthy   {"health":"true","reason":""}

    如上说明Master节点组件运行正常。

---
`授权kubelet-bootstrap用户允许请求证书`

    kubectl create clusterrolebinding kubelet-bootstrap \
    --clusterrole=system:node-bootstrapper \
    --user=kubelet-bootstrap



---

### kubelet 
---
`kubelet是 kubernetes 工作节点上的一个代理组件，运行在每个节点上。由于我的三台服务都是工作节点，所以也都需要装kubelet和kube-proxy`
`apiserver <-> kubelet <-> pod`
---
`创建服务`


    cat > /usr/lib/systemd/system/kubelet.service << EOF
    [Unit]
    Description=Kubernetes Kubelet
    After=docker.service
    
    [Service]
    EnvironmentFile=/usr/local/kubernetes/conf/kubelet.conf
    ExecStart=/usr/local/kubernetes/bin/kubelet \$KUBELET_OPTS
    Restart=on-failure
    LimitNOFILE=65536
    
    [Install]
    WantedBy=multi-user.target
    EOF
---
`创建服务配置文件`

    cat > /usr/local/kubernetes/conf/kubelet.conf << EOF
    KUBELET_OPTS="--logtostderr=false \\
    --v=2 \\
    --log-dir=/usr/local/kubernetes/logs \\
    --network-plugin=cni \\
    --hostname-override=k8s-master1 \\
    --kubeconfig=/usr/local/kubernetes/conf/kubelet.kubeconfig \\
    --bootstrap-kubeconfig=/usr/local/kubernetes/conf/bootstrap.kubeconfig \\
    --config=/usr/local/kubernetes/conf/kubelet-config.yml \\
    --cert-dir=/usr/local/kubernetes/ssl \\
    --pod-infra-container-image=k8s.gcr.io/pause:3.6"
    EOF

---
`创建k8s kubelet资源文件`

    cat > /usr/local/kubernetes/conf/kubelet-config.yml << EOF
    kind: KubeletConfiguration
    apiVersion: kubelet.config.k8s.io/v1beta1
    address: 0.0.0.0
    port: 10250
    readOnlyPort: 10255
    cgroupDriver: systemd
    clusterDNS:
    - 10.0.0.2
    clusterDomain: cluster.local 
    failSwapOn: false
    authentication:
      anonymous:
        enabled: false
      webhook:
        cacheTTL: 2m0s
        enabled: true
      x509:
        clientCAFile: /usr/local/kubernetes/ssl/ca.pem 
    authorization:
      mode: Webhook
      webhook:
        cacheAuthorizedTTL: 5m0s
        cacheUnauthorizedTTL: 30s
    evictionHard:
      imagefs.available: 15%
      memory.available: 100Mi
      nodefs.available: 10%
      nodefs.inodesFree: 5%
    maxOpenFiles: 1000000
    maxPods: 110
    EOF

---
    KUBE_CONFIG="/usr/local/kubernetes/conf/bootstrap.kubeconfig"
    KUBE_APISERVER="https://49.233.4.79:6443" # apiserver IP:PORT
    TOKEN="f41424f202b2c2e71da40ce20d32f1d2" # 与token.csv里保持一致  /usr/local/kubernetes/conf/token.csv 
    
    # 生成 kubelet bootstrap kubeconfig 配置文件
    kubectl config set-cluster kubernetes \
      --certificate-authority=/usr/local/kubernetes/ssl/ca.pem \
      --embed-certs=true \
      --server=${KUBE_APISERVER} \
      --kubeconfig=${KUBE_CONFIG}
      
    kubectl config set-credentials "kubelet-bootstrap" \
      --token=${TOKEN} \
      --kubeconfig=${KUBE_CONFIG}
      
    kubectl config set-context default \
      --cluster=kubernetes \
      --user="kubelet-bootstrap" \
      --kubeconfig=${KUBE_CONFIG}
      
    kubectl config use-context default --kubeconfig=${KUBE_CONFIG}

    ll

---
    
    systemctl daemon-reload
    systemctl stop kubelet
    systemctl start kubelet
    systemctl enable kubelet
    systemctl status kubelet -l    

---

    kubectl get csr

    kubectl certificate approve  node-csr-KbHieprZUMOvTFMHGQ1RNTZEhsSlT5X6wsh2lzfUry4
    certificatesigningrequest.certificates.k8s.io/node-csr-KbHieprZUMOvTFMHGQ1RNTZEhsSlT5X6wsh2lzfUry4 approved

---

`部署kube-proxy`

    cat > /usr/local/kubernetes/conf/kube-proxy.conf << EOF
    KUBE_PROXY_OPTS="--logtostderr=false \\
    --v=2 \\
    --log-dir=/usr/local/kubernetes/logs \\
    --config=/usr/local/kubernetes/conf/kube-proxy-config.yml"
    EOF

---
    
    cat > /usr/local/kubernetes/conf/kube-proxy-config.yml << EOF
    kind: KubeProxyConfiguration
    apiVersion: kubeproxy.config.k8s.io/v1alpha1
    bindAddress: 0.0.0.0
    metricsBindAddress: 0.0.0.0:10249
    clientConnection:
      kubeconfig: /usr/local/kubernetes/conf/kube-proxy.kubeconfig
    hostnameOverride: k8s-master1
    clusterCIDR: 10.244.0.0/16
    EOF

---
  
    cd /usr/local/kubernetes/ssl
    
    cat > kube-proxy-csr.json << EOF
    {
      "CN": "system:kube-proxy",
      "hosts": [],
      "key": {
        "algo": "rsa",
        "size": 2048
      },
      "names": [
        {
          "C": "CN",
          "L": "ShangHai",
          "ST": "ShangHai",
          "O": "k8s",
          "OU": "System"
        }
      ]
    }
    EOF
    
    cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-proxy-csr.json | cfssljson -bare kube-proxy
    ll


---

`生成kube-proxy.kubeconfig文件`
  
    KUBE_CONFIG="/usr/local/kubernetes/conf/kube-proxy.kubeconfig"
    KUBE_APISERVER="https://49.233.4.79:6443"
    
    kubectl config set-cluster kubernetes \
      --certificate-authority=/usr/local/kubernetes/ssl/ca.pem \
      --embed-certs=true \
      --server=${KUBE_APISERVER} \
      --kubeconfig=${KUBE_CONFIG}
      
    kubectl config set-credentials kube-proxy \
      --client-certificate=/usr/local/kubernetes/ssl/kube-proxy.pem \
      --client-key=/usr/local/kubernetes/ssl/kube-proxy-key.pem \
      --embed-certs=true \
      --kubeconfig=${KUBE_CONFIG}
      
    kubectl config set-context default \
      --cluster=kubernetes \
      --user=kube-proxy \
      --kubeconfig=${KUBE_CONFIG}
      
    kubectl config use-context default --kubeconfig=${KUBE_CONFIG}

---

    cat > /usr/lib/systemd/system/kube-proxy.service << EOF
    [Unit]
    Description=Kubernetes Proxy
    After=network.target
    
    [Service]
    EnvironmentFile=/usr/local/kubernetes/conf/kube-proxy.conf
    ExecStart=/usr/local/kubernetes/bin/kube-proxy \$KUBE_PROXY_OPTS
    Restart=on-failure
    LimitNOFILE=65536
    
    [Install]
    WantedBy=multi-user.target
    EOF

---

    systemctl daemon-reload
    systemctl stop kube-proxy
    systemctl start kube-proxy
    systemctl enable kube-proxy
    systemctl status kube-proxy -l





    


      ", + "subType": "00" + } + }, + "size": 0, + "_class": "com.g.estate.entity.BlogInfo", + "order": 12, + "owner": "3272499474" +},{ + "_id": { + "$oid": "63061166efb4290402c08b4b" + }, + "bid": "2022082419545600000000000001", + "title": "统计学・数学・線形代数", + "btId": "2022051700024800000000000003", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "order": 1, + "_class": "cn.violin.home.book.entity.BlogInfo", + "owner": "3272499474" +},{ + "_id": { + "$oid": "63061179efb4290402c08b4c" + }, + "bid": "2022082419546500000000000002", + "title": "保证金实例", + "btId": "2022051700024800000000000003", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "order": 2, + "_class": "cn.violin.home.book.entity.BlogInfo", + "owner": "3272499474" +},{ + "_id": { + "$oid": "630cb80a57a41969f5abb5f1" + }, + "bid": "2022082920585700000000000001", + "title": "工具函数", + "btId": "2022051700024800000000000003", + "content": { + "$binary": { + "base64": "IyMgcGFuZGFzCi0tLQojIyMgMS4gUm9sbGluZwoKPiByb2xsaW5nIOWHveaVsCDjgJBSb2xsaW5nIHdpbmRvdyBmdW5jdGlvbnPjgJEKCltEb2N1bWVudF0oaHR0cHM6Ly9wYW5kYXMucHlkYXRhLm9yZy9wYW5kYXMtZG9jcy92ZXJzaW9uLzEuMy9yZWZlcmVuY2UvYXBpL3BhbmRhcy5TZXJpZXMucm9sbGluZy5odG1sI3BhbmRhcy5TZXJpZXMucm9sbGluZykKCiAgICBTZXJpZXMucm9sbGluZyh3aW5kb3csIG1pbl9wZXJpb2RzPU5vbmUsIGNlbnRlcj1GYWxzZSwgd2luX3R5cGU9Tm9uZSwgb249Tm9uZSwgYXhpcz0wLCBjbG9zZWQ9Tm9uZSwgbWV0aG9kPSdzaW5nbGUnKQogICAgRGF0YUZyYW1lLnJvbGxpbmcod2luZG93LCBtaW5fcGVyaW9kcz1Ob25lLCBjZW50ZXI9RmFsc2UsIHdpbl90eXBlPU5vbmUsIG9uPU5vbmUsIGF4aXM9MCwgY2xvc2VkPU5vbmUsIG1ldGhvZD0nc2luZ2xlJykKCiAgICB0aGUgUm9sbGluZyBmdW5jdGlvbiB3aWxsIHJldHVybiBhIFJvbGxpbmcgT2JqZWN0LgoKLSBSb2xsaW5nLm1lYW4g5rua5Yqo5bmz5Z2HKHJvbGxpbmcgbWVhbikKCiMjIyAyLmRyb3BuYSDplqLmlbAK55So5p2l5YmU6ZmkRGF0YWZyYW1l5Lit55qE56m65YC844CCCgo+IERhdGFmcmFtZSA9IERhdGFmcmFtZS5kcm9wbmEoKQogIAoKIyMgdGFsaWIKLS0tCiMjIyBTaW1wbGUgTW92aW5nIEF2ZXJhZ2XvvIxTTUEKCj4g5pWw5a2m5YWs5byP77yaIFNNQSA9IChDPHN1Yj4xPC9zdWI+ICsgQzxzdWI+Mjwvc3ViPiArIEM8c3ViPjM8L3N1Yj4gKyBDPHN1Yj40PC9zdWI+ICsg4oCm4oCmICsgQzxzdWI+bjwvc3ViPikgLyBuCgo+IHRhbGliLlNNQShkYXRhLCAyMCkKICAgICAgICAgICAgICAgICAgCiMjIyAKCiMjIG1hdHBsb3RsaWIKLS0tCiMjIyBjYW5kbGVzdGlja19vaGxjIChL57q/KQo+IHBpcCBpbnN0YWxsIG1wbF9maW5hbmNlCgoKIyMgbnVtcHkKLS0tCiMjIyBjb3JyY29lZiDplqLmlbAKY29ycmNvZWblh73mlbDnlKjmnaXorqHnrpfnn6npmLXnm7jlhbPns7vmlbAKKDEpY29ycmNvZWYoeCnvvJroi6V45Li65LiA5Liq55+p6Zi177yM6L+U5Zue55qE5YiZ5piv5LiA5Liq55u45YWz57O75pWw55+p6Zi177yM5YW25bC65a+45LiO55+p6Zi1eOS4gOagt+OAggoKKDIpY29ycmNvZWYoeCwgeSnvvJrorqHnrpfliJflkJHph49444CBeeeahOebuOWFs+ezu+aVsO+8jOimgeaxgnjjgIF55YW35pyJ55u4562J55qE5YWD57Sg5Liq5pWw44CC5aaC5p6ceOOAgXnmmK/nn6npmLXvvIzpgqPkuYhjb3JyY29lZuWHveaVsOS8muWwhuWFtui9rOaNouS4uuWIl+WQkemHj++8jOebuOW9k+S6jmNvcnJjb2VmKFt4KDopLHkoOildKeOAggo+IGNvcnJjb2VmKHgsIHkpCgo+IAojIyMgc3RkIOagh+WHhuW3rgo+IG5wLnN0ZChkZikKIyMjIAoKCg==", + "subType": "00" + } + }, + "size": 0, + "order": 3, + "_class": "cn.violin.home.book.entity.BlogInfo", + "owner": "3272499474" +},{ + "_id": { + "$oid": "630eb09957a41969f5abb5f2" + }, + "bid": "2022083108519100000000000002", + "title": "python虚拟环境", + "btId": "2022051700024800000000000003", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "order": 4, + "_class": "cn.violin.home.book.entity.BlogInfo", + "owner": "3272499474" +},{ + "_id": { + "$oid": "6315e26a57a41969f5abb5f3" + }, + "bid": "2022090519500800000000000003", + "title": "量化投资与机器学习1", + "btId": "2022051700024800000000000003", + "content": { + "$binary": { + "base64": "IyMg55uR552j5a2m5LmgCuebkeedo+WtpuS5oO+8muaIkeS7rOaVmeiuoeeul+acuuWmguS9leWBmuS6i+aDhQo+IOaIkeS7rOe7meeul+azleS4gOS4quaVsOaNrumbhu+8jOW5tuS4lOe7meWumuato+ehruetlOahiO+8mwo+IOaVsOaNrumbhuS4reeahOavj+S4quagt+acrOmDveacieebuOW6lOeahOato+ehruetlOahiO+8jOWGjeagueaNrui/meS6m+agt+acrOS9nOWHuumihOa1i++8mwo+IOWNs+ebkeedo+WtpuS5oOS4reeahOagt+acrOS4jeaYr+mDveebuOWQjOeahO+8jOavj+S4quagt+acrOmDveacieiHquW3seeahOagh+etvuOAggoKCiMjIOmdnuebkeedo+WtpuS5oArpnZ7nm5HnnaPlrabkuaDvvJrmiJHku6zorqnorqHnrpfmnLroh6rlt7LlrabkuaAKPiDpnZ7nm5HnnaPlrabkuaDmmK/mjIfvvJrmsqHmnInmoIfnrb7ov5nkuIDmpoLlv7XvvIzmiYDmnInnmoTmlbDmja7pg73mmK/kuIDmoLfnmoTvvIzmlYXml6Dnm5HnnaPlrabkuaDkuK3vvIzlj6rmnInkuIDkuKrmlbDmja7pm4YKCi0tLQojIyDln7rnoYDmpoLlv7UKCiMjIyDlhYjpqozmpoLnjocKCiMjIyDlkI7pqozmpoLnjocKCiMKCgoKIyMg5py65qKw5a2m5Lmg566X5rOV5Z+656GA5qGI5L6LCgrmnIDkuLrlub/ms5vnmoTkuKTnp43liIbnsbvmqKHlnovmmK8gKirlhrPnrZbmoJHmqKHlnosqKiAqKuactOe0oOi0neWPtuaWr+aooeWeiyoqCiMjIyDmnLTntKDotJ3lj7bmlq/nrpfms5UK5py057Sg6LSd5Y+25pav5qih5Z6L77yITmFpdmUgQmF5ZXNpYW4gTW9kZWzvvIxOQk3vvIkKCueJueeCue+8mgogICAgCiAgICDlj4LmlbDlvojlsJHvvIzlr7nnvLrlpLHmlbDmja7kuI3lpKrmlY/mhJ8KCueul+azleWOn+eQhu+8mgoKPiDorr7mnInmoLfmnKzmlbDmja7pm4bvvIwqRD17ZDxzdWI+MTwvc3ViPiwgZDxzdWI+Mjwvc3ViPiwg44O744O744O7LCBkPHN1Yj5uPC9zdWI+fSoKPiDlr7nlupTmoLfmnKzmlbDmja7nmoTnibnlvoHlsZ7mgKfpm4bkuLoqWD17eDxzdWI+MTwvc3ViPiwgeDxzdWI+Mjwvc3ViPiwg44O744O744O7LCB4PHN1Yj5kPC9zdWI+fSoKPiDnsbvlj5jph4/kuLoqWT17eTxzdWI+MTwvc3ViPiwgeTxzdWI+Mjwvc3ViPiwg44O744O744O7LCB5PHN1Yj5tPC9zdWI+fSosIOWNs0Tlj6/ku6XliIbkuLp5PHN1Yj5tPC9zdWI+5YiG57G7CuWFtuS4rSDnm7jkupLni6znq4vkuJTpmo/mnLrvvIzliJkg55qE5YWI6aqM5qaC546HCgoKCgo=", + "subType": "00" + } + }, + "size": 0, + "order": 5, + "_class": "cn.violin.home.book.entity.BlogInfo", + "owner": "3272499474" +},{ + "_id": { + "$oid": "63180b8057a41969f5abb5f4" + }, + "bid": "2022090711097700000000000004", + "title": "线性代数", + "btId": "2022051700024800000000000003", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "order": 6, + "_class": "cn.violin.home.book.entity.BlogInfo", + "owner": "3272499474" +},{ + "_id": { + "$oid": "6336543957a41969f5abb5f9" + }, + "bid": "2022093010286500000000000007", + "title": "高等数学（上）数列，函数，极限", + "btId": "2022051700024800000000000003", + "content": { + "$binary": { + "base64": "[高等数学](https://www.bilibili.com/video/BV1864y1T7Ks/?spm_id_from=333.999.0.0)

## 第一部分 高等数学学习路线

高等数学分为上下两册，并且大体上分为极限，导数和积分三个部分，而每个部分都分为一元函数和多元函数

> 极限

一元函数 $ y = f(x)$
  多元函数 $ z = f(x\,y)$
应用 ---->>主要是求极限的各种方法

> 导数，

一元函数

$$
\frac{dy}{dx}
$$

多元函数(偏导数) $ z = f(x\text{,}y)$
应用 ---->>物理应用，经济应用和几何应用，解析几何应用

> 积分

一元函数 （定积分和不定积分）
多元函数 （重积分，曲线积分和曲面积分)
应用 ---->>物理应用，经济应用和几何应用，解析几何应用

## 第一章 函数与极限

### 1.1 映射

以下概念的理解

> 满射
> 单射
> 假设有一个单射 y = f(x), 定义逆映射 $ f^{-1}$
> 复合映射$ fog $
> **注意**，映射 的两头 不都是数集，这个很重要，比如说，映射的值域是 学生名称，映射的定义域是学生号

### 2.2 函数

函数是一种特殊的映射，定义域和值域都是数集。
函数的两个要素，定义域(D)，和映射法则(f)

> **特殊的函数**
> 单调函数对应的单射
> 常值函数
> 绝对函数
> 符号函数，即分段常值函数
> 取整函数 y = [x] 不超过 x 的最大整数，[-1.3] = -2 [0.36] = 0 [3] = 3

> **函数的特性**
> ならば記号　 ⇒ 日本語入力（ならば）
> 全て記号　 ∀ 　日本語入力（すべて）
> 存在記号　 ∃ 　日本語入力（存在）
> 同値記号　 ⇔ 　日本語入力（同値）とう
> 属する記号　 ∊ 　日本語入力（属する）
> 無限記号　 ∞ 　日本語（無限）

> 性质
> 有界性，最重要的有界性质：若 f(x) 在 E 上既有上界还有下界，则称 f(x)有界，否则是无界，「f(x)在 E 上有界」⇔「∀M>0, $∀x$ ∊ $E$,有 f(x)≦M」
> 单调性，单调递增和单调递减
> 奇偶性，偶函数 f(x) = f(-x), f(x) = -f(-x)
> 周期性，f(x) = f(x + T)，则，f(x)是以 T 为周期的周期函数
> 反函数和复合函数

> 函数的四则运算

> 基本初等函数
> 幂函数，指数函数，对数函数，三角函数，反三角函数
> 分段函数不是基本函数

### 2.3 数列极限

极限严格数学定义
如果用足够小的正实数 ε「イプシロン、無視できる小さいぐらい値と考える」
作为衡量接近程度的指标，则，当|x<sub>n</sub>-1| < ε、表示在 ε 指标下足够接近，无论 ε 是如何小的正数，总可以找到正整数 N，使数列除了开始的 N 项以外，自第 N+1 项开始，后面的一切项都在 a=1 的 ε 邻域 U(1, ε)内，
**收敛数列的性质**
定理 1：收敛数列，极限的唯一性
定理 2：收敛数列，一定有界
定理 3：收敛数列的保号性
定理 3：收敛数列的子收敛数列极限是相同的。

### 2.4 函数的极限

**自变量趋于正无限大时的函数的极限**
定義：
对于任意给定的正数 ε（ε 足够小），总存在$X > 0$, $∀x > X$时，满足$|f(x) - A| < ε$
此时，称常数 A 为函数$f(x)$在$x→+\infty$时的极限。
$ε-X$

$$
\lim_{x→+\infty}f(x) = A
$$

$∀ε>0$, $∃X>0$, $x>X$时,有$|f(x) - A| < ε$
**自变量趋于负无限大时的函数的极限**

$$
\lim_{x→-\infty}f(x) = A
$$

$∀ε>0$, $∃X>0$, $x<-X$时,有$|f(x) - A| < ε$
**自变量趋于无穷时的函数的极限**

$$
\lim_{x→\infty}f(x) = A
$$

$∀ε>0$, $∃X>0$, $|x|>X$时,有$|f(x) - A| < ε$

### 2.5 无穷小和无穷大

无穷小

$$
\lim_{x→X}f(x) = 0 ⇔ \text{x趋近于X的极限是0,我们就说无穷小}
$$

无穷大

$$
\lim_{x→X}f(x) = \infty ⇔ \text{x趋近于X的极限是} \infty \text{, 我们就说无穷大}
$$

无穷小和无穷大，是一个函数，不是一个数，无穷大是无界的，

### 2.6 极限存在法则，两个重要的极限

**1.夹逼准则**
$∃n_0$ ∊ $N$, 当$n$大于$n_0$时，有

$$
y_n ≦x_n ≦ z_n
$$

如果

$$
\lim_{n→+\infty}y_n = a \text{,} \lim_{n→+\infty}z_n = a
$$

则

$$
\lim_{n→+\infty}x_n = a
$$

**第一个重要的极限**

$$
\lim_{x→0} \frac{sinx}{x} = 1
$$

证明：
由画图可知，在 0<x<π/2，存在

$$
 cosx < \frac{sinx}{x} < 1
$$

由加比准则可知，

$$
\lim_{x→0} \frac{sinx}{x} = 1
$$

**2. 单调有界数列必有极限**
函数也有类似的准则。

### 2.7 无穷小的比较

无穷小的加算，减算，乘积都是无穷小，但是无穷小的商则会出现不同情况。
α、β 都是自变量变化过程中的无穷小

$$
\lim \frac{\beta}{\alpha}
$$

如果

$$
\lim \frac{\beta}{\alpha} = 0 \text{,} \beta \text{是比} \alpha \text{高阶的无穷小,记作}，\beta=o(\alpha)(x→0)
$$

如果

$$
\lim \frac{\beta}{\alpha} = \in\text{,} \beta \text{是比} \alpha \text{低阶的无穷小}
$$

如果

$$
\lim \frac{\beta}{\alpha} = c(c≠0)\text{,} \beta \text{和} \alpha \text{同阶的无穷小}
$$

如果

$$
\lim \frac{\beta}{\alpha} = 1\text{,} β \text{和} α \text{等价的无穷小, 记作}\alpha \text{～} \beta
$$

如果

$$
\lim \frac{\beta}{\alpha} = c(c≠0)\text{,} \beta \text{是关于} \alpha \text{的k阶的无穷小}
$$

**定理 1**:β 和 α 同阶的无穷小的充分必要条件是 $\beta = \alpha + o(\alpha)$

### 2.8 函数的连续性和间断性

有增量$Δx$、则增量
$Δy = f(x_0 + Δx) - f(x_0)$
**定义** 设函数 f(x)在点 x<sub>0</sub> 的某一个邻域内定义，如果，

$$
\lim_{Δx→0} Δy = \lim_{Δx→0} [f(x_0 + Δx) - f(x_0)] = 0
$$

那么则称函数 y=f(x)在点 x0 出连续。
即

$$
\lim_{x→x_0} f(x) = f(x_0)
$$

那么则称 x 在 x0 处连续
**左连续**
**右连续**

### 2.9 连续函数的运算和初等函数的连续性

1. 连续函数的商积和差，也是连续函数（分母不等于 0 时）
2. 反函数和复合函数的连续性
3. 初等函数在定义域内都是连续的
还

", + "subType": "00" + } + }, + "size": 0, + "order": 7, + "_class": "cn.violin.home.book.entity.BlogInfo", + "owner": "3272499474" +},{ + "_id": { + "$oid": "633e677a57a41969f5abb5fc" + }, + "bid": "2022100613288800000000000008", + "title": "高等数学（上）导数和微分", + "btId": "2022051700024800000000000003", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "order": 8, + "_class": "cn.violin.home.book.entity.BlogInfo", + "owner": "3272499474" +},{ + "_id": { + "$oid": "633e6f4757a41969f5abb5fd" + }, + "bid": "2022100614018700000000000009", + "title": "高等数学（上）积分和微分方程", + "btId": "2022051700024800000000000003", + "content": { + "$binary": { + "base64": "IyMg56ys5Zub56ugIOS4jeWumuenr+WIhgotLS0KIyMjIDQuMSDljp/lh73mlbDlkozkuI3lrprnp6/liIbnmoTmpoLlv7UKKirlrprkuYkxKioK5aaC5p6c5Zyo5Yy66Ze0JEkk5LiK77yM5Y+v5a+85Ye95pWwJEYoeCkk55qE5a+85Ye95pWw5Li6JGYoeCkk77yM5Y2z5a+55Lu75LiAJHggXGluIEkkLOmDveaciQokJApGXntccHJpbWV9KHgpPWYoeCkgXHF1YWQgXHRleHR75oiWfSBkRih4KSA9IGYoeClkeAokJArpgqPkuYjlh73mlbAkRih4KSTlsLHnp7DkuLokZih4KSTvvIjmiJYkZih4KWR4JO+8ieWcqOWMuumXtCRJJOS4iueahOWOn+WHveaVsAoKKirljp/lh73mlbDlrZjlnKjlrprnkIYqKgrov57nu63lh73mlbDkuIDlrprmnInljp/lh73mlbAKCioq5a6a5LmJMioqCuWcqOWMuumXtCRJJOS4iu+8jOWHveaVsCRmKHgpJOeahOW4puacieS7u+aEj+W4uOaVsOmhueeahOWOn+WHveaVsOensOS4uiRmKHgpJOWcqOWMuumXtCRJJOS4iueahOS4jeWumuenr+WIhu+8jOiusOS9nAokJApcaW50IGYoeClkeCwgXHF1YWQgXHRleHR75YW25Lit6K6w5Y+3fSBcaW50IFx0ZXh0e+enr+WIhuWPt30KJCQKJGYoeClkeCTnp7DkuLrooqvnp6/ooajovr7lvI/vvIx456ew5Li656ev5YiG5Y+Y6YeP44CCIArljbMKJCQKXGludCBmKHgpZHggPSBGKHgpICsgQwokJArlm6DmraTvvIwkXGludCBmKHgpZHgk5Y+v5Lul6KGo56S6JGYoeCkk55qE5Lu75oSP5LiA5Liq5Y6f5Ye95pWw44CCCiMjIyDln7rmnKznp6/liIbooagK5q2k5aSE55WlCitDCiMjIyDkuI3lrprnp6/liIbnmoTmgKfotKgK5Z+65pys55qE5Zub5YiZ6L+Q566XCgojIyMgNC4yIOaNouWFg+enr+WIhuazlQrliKnnlKjnp6/liIbooajmnaXorqHnrpfnp6/liIblvI/pnZ7luLjmnInpmZDnmoTvvIzmiYDku6XmiorlpI3lkIjlh73mlbDnmoTlvq7liIbms5Xlj43ov4fmnaXmsYLkuI3lrprnp6/liIbvvIzliKnnlKjkuK3pl7Tlj5jph4/ku6PmjaLvvIzlvpfliLDnrKblkIjlh73mlbDnmoTnp6/liIbms5XvvIwKCiMjIOesrOS6lOeroCDlrprnp6/liIYKCiMjIOesrOWFreeroCDlrprnp6/liIbnmoTlupTnlKgKCiMjIOesrOS4g+eroCDlvq7liIbmlrnnqIs=", + "subType": "00" + } + }, + "size": 0, + "order": 9, + "_class": "cn.violin.home.book.entity.BlogInfo", + "owner": "3272499474" +},{ + "_id": { + "$oid": "6352618afe546b1de2f76d42" + }, + "bid": "2022102117089200000000000003", + "title": "第一章 绪论", + "btId": "2022102117088800000000000001", + "content": { + "$binary": { + "base64": "IyMgMS4xIOW8leiogAotLS0KPiDlrabkuaDnrpfms5XvvIzmnLrmorDlrabkuaDmiYDopoHnoJTnqbbnmoTkuLvopoHlhoXlrrnvvIzmmK/lhbPkuo7orqHnrpfmnLrku47mlbDmja7kuK3kuqfnlJ/jgJDmqKHlnottb2RlbOOAkeeahOeul+azle+8jOaooeWeiyDms5vmjIcg5LuO5pWw5o2u5Lit5a2m5b6X55qE57uT5p6c44CCCgotLS0KIyMgMS4yIOWfuuacrOacr+ivrQo+IOaVsOaNrumbhuOAkGRhdGEgc2V044CRCj4g5qC35pys44CQc2FtcGxl44CR5oiW6ICFIOWunuS+i+OAkGluc3RhbmNl44CRCj4g5bGe5oCn44CQYXR0cmlidXRl44CRIOaIluiAhSDnibnlvoHjgJBmZWF0dXJl44CRCj4g5bGe5oCn5YC844CQYXR0cmlidXRlIHZhbHVl44CRCj4g5bGe5oCn56m66Ze044CQYXR0cmlidXRlIHNwYWNl44CRCj4g5qC35pys56m66Ze044CQc2FtcGxlIHNwYWNl44CRCj4g5a2m5Lmg44CQbGVhcm5pbmfjgJHku47mlbDmja7kuK3lrablvpfmqKHlnovnmoTov4fnqIsg5Li6IOWtpuS5oOOAkGxlYXJuaW5n44CR5oiWIOiuree7g+OAkHRyYWluaW5n44CRCj4g6K6t57uD5pWw5o2u44CQdHJhaW5pbmcgZGF0YeOAkeiuree7g+i/h+eoi+S4reS9v+eUqOeahOaVsOaNriDkuLog6K6t57uD5pWw5o2u44CQdHJhaW5pbmcgZGF0YeOAkQo+IOiuree7g+agt+acrOOAkHRyYWluaW5nIHNhbXBsZeOAke+8jOiuree7g+aVsOaNruS4reeahOavj+S4gOS4quagt+acrCDmiJDkuLog6K6t57uD5qC35pysIOOAkHRyYWluaW5nIHNhbXBsZeOAkQo+IOiuree7g+mbhiDjgJB0cmFpbmluZyBzZXTjgJHorq3nu4PmoLfmnKwg57uE5oiQ55qE6ZuG5ZCIIOS4uiDorq3nu4Ppm4Yg44CQdHJhaW5pbmcgc2V044CRCj4g5YGH6K6+44CQaHlwb3RoZXNpc+OAkeWtpuW+l+aooeWei+WvueW6lOS6huWFs+S6juaVsOaNrueahOmtlOenjea9nOWcqOinhOW+i++8jOWNsyDlgYforr7jgJBoeXBvdGhlc2lz44CRCj4g55yf55u444CQZ3JvdW5kLXRydXRo44CR6L+Z56eN5r2c5Zyo6KeE5b6L6Ieq6Lqr77yM5YiZ56ew5Li6IOecn+ebuOOAkGdyb3VuZC10cnV0aOOAke+8jOWtpuS5oOeahOi/h+eoi+WwseaYr+S4uuS6huaJvuWHuuaIluiAhemAvOi/keecn+ebuOOAggo+IOagh+iusOOAkGxhYmVs44CR77yM5qC35pys57uT5p6c55qE5L+h5oGv77yM5Y2z5qCH6K6w44CQbGFiZWzjgJEKPiDmoLfkvovjgJBleGFtcGxl44CR77yM5oul5pyJ5LqG5qCH6K6w55qE5a6e5L6L77yM5Y2z5Li6IOagt+S+i+OAkGV4YW1wbGXjgJEKCipEKiA9IHsqeDxzdWI+MTxzdWI+PC9zdWI+PC9zdWI+KiwgKng8c3ViPjI8L3N1Yj4qLCAuLi4sKng8c3ViPm48c3ViPjwvc3ViPjwvc3ViPip9IOWFt+aciW7kuKrlrp7kvovnmoTmlbDmja7pm4YKKCp4KjxzdWI+PHN1Yj5pPC9zdWI+PC9zdWI+LCAqeSo8c3ViPmk8L3N1Yj4p6KGo56S656ysaeS4quagt+S+i+OAggoKPiAtIOWmguaenOaIkeS7rOeahOmihOa1i+eahOaYr+emu+aVo+WAvO+8jOatpOexu+WtpuS5oOeahOS7u+WKoeaIkOS4uiDliIbnsbvjgJBjbGFzc2lmaWNhdGlvbuOAkQo+IC0g5aaC5p6c5oiR5Lus55qE6aKE5rWL5piv6L+e57ut5YC877yM5q2k57G755qE5a2m5Lmg5Lu75Yqh5oiQ5Li65Zue5b2S44CQcmVncmVzc2lvbuOAkQo+IC0g5a+55LqO5Y+q5raJ5Y+K55qE5Lik5Liq57G75Yir55qE5LqM5YiG57G744CQYmluYXJ5IGNsYXNzaWZpY2F0aW9u44CR5Lu75Yqh77yM6YCa5bi45LiA5Liq5oiQ5Li65q2j57G744CQcG9zaXRpdmUgY2xhc3PjgJHlj6bkuIDkuKrnsbvkuLrlj43nsbvjgJBuZWdhdGl2ZSBjbGFzc+OAkQo+IC0g5raJ5Y+K5Yiw5aSa5Liq57G75Yir5pe277yM5YiZ5oiQ5Li65aSa5YiG57G744CQbXVsdGktY2xhc3MgY2xhc3NpZmljYXRpb27jgJHku7vliqEKCj4gLSDmoLnmja50cmFpbiBzZXQg5Lit5piv5ZCm5ZCr5pyJIGxhYmVs77yM5a2m5Lmg5Lu75Yqh5YiG5Li6IOebkeedo+WtpuS5oOOAkHN1cGVydmlzZWTjgJEg5ZKMIOaXoOebkeedo+WtpuS5oOOAkHVuc3VwZXJ2aXNlZCBsZWFybmluZ+OAkQrliIbnsbvlkozlm57lvZLmmK8g55uR552j5a2m5Lmg77yMIOiAjOiBmuexu+aYr+WQjuiAheeahOS7o+ihqOOAggoKLS0tCiMjIDEuMyDlgYforr7nqbrpl7QK5b2S57qz44CQaW5kdWN0aW9u44CR5ZKM5ryU57uO44CQZGVkdWN0aW9u44CR5piv56eR5a2m5o6o55CG55qE5Lik5aSn5omL5q6144CCCuW9kue6s+aYr+S7jueJueauiuWIsOS4gOiIrOeahOazm+WMluOAkGdlbmVyYWxpemF0aW9u44CR55qE6L+H56iL77yM5Y2z5LuO5YW35L2T55qE5LqL5a6e5b2S57uT5Ye65LiA6Iis5oCn6KeE5b6L44CCCua8lOe7juaYr+S7juS4gOiIrOWIsOeJueauiueahOeJueWMluOAkHNwZWNpYWxpemF0aW9u44CR55qE6L+H56iL77yM5LuO5Z+656GA5Y6f55CG5o6o5ryU5Ye65YW35L2T5oOF5Ya144CCCueJiOacrOepuumXtOOAkHZlcnNpb24gc3BhY2XjgJHvvIzlrZjlnKjnnYDkuIDkuKrkuI7orq3nu4Ppm4bkuIDoh7TnmoTlgYforr7pm4blkIjvvIzmiJHku6znp7DkuYvkuLrniYjmnKznqbrpl7QKCi0tLQojIyAxLjQg5b2S57qz5YGP5aW9CuaXoOiuuuWtpuS5oOeul+azlUHlpJrogarmmI7vvIzlrabkuaDnrpfms5VC5aSa56yo5ouZ77yM5LuW5Lus55qE5pyf5pyb5oCn6IO95piv55u45ZCM55qE77yM6L+Z5bCx5pivTkZM5a6a55CG77yM5Y2z5rKh5pyJ5YWN6LS555qE5Y2I6aSQ5a6a55CGCk5GTOWumueQhuacgOmHjeimgeeahOWvk+aEj+aYr++8jOWmguaenOiAg+iZkeaJgOacieeahOa9nOWcqOeahOmXrumimO+8jOaJgOacieeahOWtpuS5oOeul+azlemDveS4gOagt+Wlve+8jOiAjOeul+azleeahOS8mOWKo+W/hemhu+W7uuWcqOWFt+S9k+eahOWtpuS5oOmXrumimOS4iuOAggotLS0KIyMjIDEuNSA=", + "subType": "00" + } + }, + "size": 0, + "order": 0, + "_class": "cn.violin.home.book.entity.BlogInfo", + "owner": "3272499474" +},{ + "_id": { + "$oid": "635261a0fe546b1de2f76d43" + }, + "bid": "2022102117084500000000000004", + "title": "第二章 模型评估与选择", + "btId": "2022102117088800000000000001", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "order": 1, + "_class": "cn.violin.home.book.entity.BlogInfo", + "owner": "3272499474" +},{ + "_id": { + "$oid": "635262bbfe546b1de2f76d45" + }, + "bid": "2022102117130400000000000005", + "title": "1. 随机事件", + "btId": "2022102117130200000000000002", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "order": 0, + "_class": "cn.violin.home.book.entity.BlogInfo", + "owner": "3272499474" +},{ + "_id": { + "$oid": "63526327fe546b1de2f76d46" + }, + "bid": "2022102117154100000000000006", + "title": "2. 随机变量以及其分布率", + "btId": "2022102117130200000000000002", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "order": 1, + "_class": "cn.violin.home.book.entity.BlogInfo", + "owner": "3272499474" +},{ + "_id": { + "$oid": "63526342fe546b1de2f76d47" + }, + "bid": "2022102117153700000000000007", + "title": "3. 随机变量的重要数字特征", + "btId": "2022102117130200000000000002", + "content": { + "$binary": { + "base64": "## 1.1 样本均值
>设 $X_1,X_2,\cdots,X_n$ 为总体 $X$ 的样本，样本容量为 $n$，则样本均值为
$$
\bar{X}=\frac{1}{n}\sum_{i=1}^{n}X_i
$$

用样本均值来估计总体的期望$\mu$，$\bar{X}$是围绕$\mu$左右波动的，即多次采样计算出来的统计量 $\bar{X}$ 有的落在 $\mu$ 左边，有的落在 $\mu$ 右边，
由于 $\bar{X}$ 落在 $\mu$ 左右两侧的情况是均匀的，即 $E(\bar{X})=\mu$，所以 $\bar{X}$ 就是 $\mu$ 的无偏估计。
样本均值能够保持比较好的无偏性是因为它的计算过程本质还是一个线性过程，这个就是无偏。

## 1.2 加权平均
## 1.3 数学期望

>离散型随机变量X的分布率
$$
P\{X=x_k\}=p_k, \quad k=1,2,3...
$$
级数
$$
\sum_{k=1}^{\infty}x_kp_k
$$
绝对收敛，则称级数为随机变量X的数学期望，记为$E(X)$,即
$$
E(x) = \sum_{k=1}^{\infty}x_kp_k
$$
注意* 数学期望可能不存在。
**计算** 核心是确定分布率，数学期望，反映了随机变量X的取值的平均水平


>连续性随机变量X的分布率
概率密度函数$f(x)$
若积分
$$
\int_{-\infty}^{+\infty} x \cdot p(x)dx
$$
绝对收敛，则称积分值$\int_{-\infty}^{+\infty} x \cdot p(x)dx$为随机变量X的数学期望，记为$E(X)$
即
$$
E(x)=\int_{-\infty}^{+\infty} x \cdot p(x)dx
$$
注意绝对收敛，是取|x|

> 数学期望的性质
(1) 设C为常数，则$E(C)=C$
(2) 设$X,Y$是相互独立的随机变量，则$E(XY)=E(X) \cdot E(Y)$

## 1.4 总体方差(variance)
>设$X$是随机变量,$E\{[X-E(X)]^2 \}$存在，则称$E\{[X-E(X)]^2 \}$为随机变量X的方差，记为$D(X)$或$Var(X)$即
$$
D(X)=Var(X)=E\{[X-E(X)]^2 \}
$$

引入
$$
\sigma(X)=\sqrt{D(X)}
$$
为均方差，或者标准差。
注意：
$D(X)$表示随机变量的取值和他的数学期望的偏离程度。
$D(X)$较小，则随机变量X大多分布在数学期望附近。
$D(X)$较大，则随机变量X取值分散。
$D(X)$刻画了随机变量X的分散程度的量度。

> 离散型随机变量的方差
$$
E\{[X-E(X)]^2 \}=D(X)=Var(X)=\sigma^{2}=\sum_{k=1}^{\infty}[x_k -\mu]^{2} \cdot P_k
$$

> 连续型随机变量的方差
$$
E\{[X-E(X)]^2 \}=D(X)=Var(X)=\sigma^{2}=\int_{-\infty}^{+\infty} [x -\mu]^{2} \cdot f(x)dx
$$

> 性质
由
$$
E\{[x-E(X)]^2 \} = \int_{-\infty}^{+\infty}[x-E(X)]^2 \cdot f(x)dx
$$
$$
= \int_{-\infty}^{+\infty}x^2 \cdot f(x)dx -2xE(x)\int_{-\infty}^{+\infty}f(x)dx + E^{2}(X)\int_{-\infty}^{+\infty}f(x)dx
$$
$$
=E(x^2)-2E^{2}(x) + E^{2}(x) = E(x^2)-E^{2}(x)
$$
$$
\sigma^{2}=E(x^2)-\mu^{2}
$$
## 1.5 样本方差
> 样本方差和总体方差是不一样的，样本方差如下：
$$
S^{2}=\frac{1}{n-1} \sum_{i=1}^{n}(X_i - \bar{X})^{2}
$$

下面我们从推导一下，样本方差为什么是$\frac{1}{n-1}$ 
由方差的基本定义可知道，(样本值 - 均值) 的 平方后的 均值可知，暂时认为
$$
S^2 = \frac{1}{n}\sum_{k=1}^{n}[X_i - \bar{X}]^2 
$$ 
那么该方差的数学期望为
$$
E(S^2) = E[\frac{1}{n}\sum_{k=1}^{n}[X_i - \bar{X}]^2] 
$$
$$
E(S^2) = E[\frac{1}{n}\sum_{k=1}^{n}[(X_i - \mu) - (\bar{X} - \mu)]^2 ]
$$
$$
E(S^2) = E [\frac{1}{n}\sum_{k=1}^{n}[(X_i - \mu)^2 - (X_i - \mu)(\bar{X} - \mu) + (\bar{X} - \mu)^2] ]
$$
$$
E(S^2) = E [\frac{1}{n}\sum_{k=1}^{n}(X_i - \mu)^2 - \frac{2}{n}\sum_{k=1}^{n}(X_i - \mu)(\bar{X} - \mu) + \frac{1}{n}\sum_{k=1}^{n}(\bar{X} - \mu)^2 ]
$$
$$
E(S^2) = E [\frac{1}{n}\sum_{k=1}^{n}(X_i - \mu)^2 - \frac{2}{n}(\bar{X} - \mu)\sum_{k=1}^{n}(X_i - \mu) + \frac{1}{n}\sum_{k=1}^{n}(\bar{X} - \mu)^2 ]
$$
$$
E(S^2) = E [\frac{1}{n}\sum_{k=1}^{n}(X_i - \mu)^2 - \frac{2}{n}(\bar{X} - \mu)n(\bar{X} - \mu) + \frac{1}{n}(\bar{X} - \mu)^2 ]
$$
$$
E(S^2) = E [\frac{1}{n}\sum_{k=1}^{n}(X_i - \mu)^2 - \frac{1}{n}(\bar{X} - \mu)^2 ]
$$
$$
E(S^2) = E [\frac{1}{n}(\sum_{k=1}^{n}(X_i - \mu)^2 - (\bar{X} - \mu)^2) ]
$$

$$
E(S^2) = E [\frac{1}{n}\sum_{k=1}^{n}((X_i - \mu)^2 - (\bar{X} - \mu)^2) ]
$$

$$
E(S^2) = E [\frac{1}{n}\sum_{k=1}^{n}(X_i - \mu)^2] - \frac{1}{n}E[(\bar{X} - \mu)^2 ]
$$

$$
E(S^2) = \sigma^2 - \frac{1}{n}E[(\bar{X}^{2} -2\bar{X}\mu  + \mu^2) ]
$$

$$
E(S^2) = \sigma^2 - \frac{1}{n}(E(\bar{X}^{2}) -2\mu E(\bar{X})  + E(\mu^2)) 
$$

$$
E(S^2) = \sigma^2 - \frac{1}{n}(E(\bar{X}^{2}) - E(\mu^2)) 
$$

$$
E(S^2) = \sigma^2 - \frac{1}{n}\sigma^2 = \frac{n-1}{n}\sigma^2 \neq \sigma^2
$$
我们看出，$E(S^2)$和总体方差是不相等的，即是有偏向的，为了修正这个问题，  
我们需要重新估计得到
$$
S^2 = \frac{1}{n-1}\sum_{k=1}^{n}[X_i - \bar{X}]^2  
$$

## 1.6 均方误差（mean-square error, MSE）
均方误差是 反映估计量与被估计量之间差异程度的一种度量。 
>一般地，在样本量一定时，评价一个点估计的好坏标准使用的指标 是点估计与参数真值 的距离的函数，最常用的函数是距离的平方.  
由于估计量 具有随机性，可以对该函数求期望，这就是下式给出的均方误差： 
$$
E(X_i) = \frac{1}{n} \sum_{i=1}^{n} (f(x_i) -y_i)^2
$$其中 $f(x_i)$ 为预测值，$y_i$为真值。

## 1.6 相关系数
## 1.7 矩阵

## 7.2 矩

**矩**

1. $k$阶矩($k$阶原点矩)

设$X$是随机变量，若
$$
E(X^k), \quad k=1,2,3...
$$
存在，称它为$X$的$k$阶**原点矩**，简称$k$阶矩。

注意：k=1,是1阶矩，$E(X)$，1阶矩是数学期望
k=2，是2阶矩，$E(x^2)$的数学期望。

$$
E(X^k)=\int_{-\infty}^{+\infty}x^{k}f(x)dx, \quad k=1,2,3...
$$

2. $k$阶中心矩

设$X$是随机变量，若
$$
E\{[X-E(X)]^k\}, \quad k=2,3...
$$
存在，称它为$X$的$k$阶**中心矩**。
注意：k=2的时候，2阶中心距就是方差。

$$
E\{[X-E(X)]^k\}=\int_{-\infty}^{+\infty}[X-E(X)]^kf(x)dx, \quad k=2,3...
$$

3. $k+l$阶混合矩

设$(X+Y)$是随机变量，若
$$
E(X^{k}Y^{l}), \quad k,l=2,3...
$$
存在，称它为$X,Y$的$k+l$阶**混合矩**。

注意：k=l=1的时候，E(XY)的数学期望。

4. $k+l$阶混合中心矩

设$(X+Y)$是随机变量，若
$$
E([X-E(X)]^{k}[Y-E(Y)]^{l}), \quad k,l=1,2,3...
$$
存在，称它为$X,Y$的$k+l$阶**混合中心矩**。

注意：当$k=l=1$的时候，$k+l=2$,即2阶混合中心距，协方差$Cov(X,Y)$是$X$和$Y$的2阶混合中心距。

**协方差矩阵**

对n维随机变量使用协方差矩阵研究。

1. 2维随机变量的协方差矩阵
设2维随机变量(X,Y)有四个2阶中心距，分别为
$c_{11}=E\{[X-E(X)]^{2}\}$
$c_{12}=E\{[X-E(X)][Y-E(Y)]\}$
$c_{21}=E\{[Y-E(Y)][X-E(X)]\}$
$c_{22}=E\{[Y-E(Y)]^{2}\}$
将他们排成矩阵的形式
$$
\begin{pmatrix}
c_{11} & c_{12} \\
c_{21} & c_{22} \\
\end{pmatrix} \tag{1}
$$
这个矩阵就成为随机变量(X,Y)的协方差矩阵。是一个对称矩阵

2. n维随机变量$(X_1,X2,...X_n)$的协方差矩阵
$c_{ij}=E[X_i-E[X_i]]E[X_j-E(X_j)]$的协方差都存在。
则称矩阵
$$
\begin{pmatrix}
c_{11} & c_{12} & ... & c_{1n}\\
c_{21} & c_{22} & ... & c_{2n}\\
\vdots & \vdots & \ & \vdots\\
c_{n1} & c_{n2} & ... & c_{nn}\\
\end{pmatrix} \tag{1}
$$
称为n维随机变量$(X_1,X2,...X_n)$的协方差矩阵

在数理统计中，往往并不知道n维随机变量的概率分布，或者太复杂，以至于无法处理，因此在实际应用中协方差矩阵就很重要了。
", + "subType": "00" + } + }, + "size": 0, + "order": 2, + "_class": "cn.violin.home.book.entity.BlogInfo", + "owner": "3272499474" +},{ + "_id": { + "$oid": "63526366fe546b1de2f76d48" + }, + "bid": "2022102117160500000000000008", + "title": "4. 参数估计", + "btId": "2022102117130200000000000002", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "order": 3, + "_class": "cn.violin.home.book.entity.BlogInfo", + "owner": "3272499474" +},{ + "_id": { + "$oid": "6352637dfe546b1de2f76d49" + }, + "bid": "2022102117166600000000000009", + "title": "5. 置信区间", + "btId": "2022102117130200000000000002", + "content": { + "$binary": { + "base64": "IyMgNS4xIOe9ruS/oeWMuumXtAotLS0KPiDlrprkuYkg6K6+5oC75L2TJFgk55qE5YiG5biD5Ye95pWwJEYoeDtcdGhldGEpJCzlkKvmnInkuIDkuKrkvY3nva7lj4LmlbAkXHRoZXRhLCBcdGhldGEgXGluIFxUaGV0YSwgXFRoZXRhJOaYryAkXHRoZXRhJOeahOWPr+iDveeahOWPluWAvOiMg+WbtOOAgiAgCuWvueS6jue7meWumuWAvCAkIDA8XGFscGhhIDwgMSTvvIzmnaXoh6pY55qE5LiA5Liq5qC35pysJChYXzEsWF8yLFxjZG90cywgWF9uKSTnoa7lrprnmoTkuKTkuKrnu5/orqHph4/vvIwkXHRoZXRhPVx0aGV0YShYXzEsWF8yLFxjZG90cywgWF9uKSTlkowkXGJhcntcdGhldGF9PVx0aGV0YShYXzEsWF8yLFxjZG90cywgWF9uKSBccXVhZCAoXHRoZXRhIDwgXGJhcntcdGhldGF9KSQgIArlr7nkuo7ku7vmhI/nmoQkXHRoZXRhIFxpbiBcVGhldGEk5ruh6Laz77yMCiQkClBce1x1bmRlcmxpbmV7XHRoZXRhfShYXzEsWF8yLFxjZG90cywgWF9uKSA8IFx0aGV0YSA8IFxiYXJ7XHRoZXRhfShYXzEsWF8yLFxjZG90cywgWF9uKSBcfSBcZ2UgCiQkCuWImeensOmaj+acuuWMuumXtCQoXHVuZGVybGluZXtcdGhldGF9LCBcYmFye1x0aGV0YX0pJOaYryDnva7kv6HmsLTlubPkuLogJDEtIFxhbHBoYSQg55qE572u5L+h5Yy66Ze044CCCiRcdW5kZXJsaW5le1x0aGV0YX0k5Li6572u5L+h5LiL6ZmQ77yMJFxiYXJ7XHRoZXRhfSTkuLrnva7kv6HkuIrpmZDvvIwkMS0gXGFscGhhJOS4uue9ruS/oeawtOW5s+OAggoKIyMgNS4xIOe9ruS/oeWMuumXtA==", + "subType": "00" + } + }, + "size": 0, + "order": 4, + "_class": "cn.violin.home.book.entity.BlogInfo", + "owner": "3272499474" +},{ + "_id": { + "$oid": "635265bbfe546b1de2f76d4a" + }, + "bid": "2022102117264100000000000010", + "title": "关于Oauth的第三方授权登录", + "btId": "00000000000004", + "content": { + "$binary": { + "base64": "IyMg5YWz5LqOdmlsaW4taG9tZeeahCDlronlhajorqTor4EKLS0tCumHh+eUqHRoaXJkIHBhcnTvvIjnrKzkuInmlrnvvInorqTor4EgKyB0b2tlbu+8jOaaguaXtuWPquaUr+aMgeeZvuW6puS6keiupOivgeOAggoK6YeH55SodG9rZW4g5piv6Ziy5q2iIOiuvuWkh+S4ouWkseetieaDheWGteWPkeeUn+aXtu+8jOWPr+S7peWwhueUqOaIt+aaguaXtuWJlOmZpOenn+aIt+S9k+ezu++8jOS/neivgeaVsOaNruWuieWFqOOAguaYr+S9nOS4ump3dOiupOivgeeahOS4gOenjeihpeWFheaJi+auteOAggoK5Z+65pys55qE6K6k6K+BZmxvd+WmguS4i++8mgoKPiDnlKjmiLcgLT4g55m75b2VIHZpb2xpbi1ob21lIOe9keermSAgCgo+IHRva2VuIGNoZWNrIC0+IOayoeaciXRva2Vu55qE6K+d77yM6L+b5YWld29sY29tZSDpobXpnaLvvIzov5vlhaXnmbvlvZXor7Hlr7zpobXpnaLvvIzmnIl0b2tlbuWImei/m+WFpWhvbWXpobXpnaIgIAoKPiDngrnlh7sg55m+5bqm5LqR55m75b2VIOi3s+i9rOWIsCDnmb7luqbmiavnoIEg6aG16Z2iCgo+IOaJq+eggeaIkOWKn++8jOi/lOWbniDlm57osINjb2Rl55qE6L+e5o6l77yM5ZCM5pe25L2/55SoY29kZSDorr/pl64gdmlvbGluLWJvb2sg6L+b5YWldG9rZW7ojrflj5YKCj4gdmlvbGluLWJvb2sg6I635Y+W5YiwY29kZeWQjiDlkJEg55m+5bqm5LqRIOi/m+ihjOiupOivge+8jOiOt+WPliB0b2tlbu+8jOWQjOaXtui/m+ihjOenn+aIt2NoZWNr77yM5rKh5pyJ56ef5oi35oOF5oql55qE6K6k6K+B55So5oi377yM6L+U5Zuec29ycnlwYWdl77yM5pyJ56ef5oi35oOF5oql55qE6K6k6K+B55So5oi377yM6Lef5paw6K6k6K+BdG9rZW7liLByZWRpc++8jOW5tuS4lOmHjeWumuWQkeWIsCB2aW9saW4taG9tZS1tYW5hZ2Ug6L+e5o6lCgo+IOino+aekCB2aW9saW4taG9tZS1tYW5hZ2Ug6L+e5o6l77yM6I635Y+WdG9rZW7vvIzpgJrov4d0b2tlbiDvvIzlkJF2aW9saW4tYm9va+iOt+WPluenn+aIt+WfuuacrOS/oeaBr++8jOeEtuWQjiDot7PovazliLBob21l6aG16Z2iCgo+IOiHs+atpCDorqTor4Eg5a6M5LqGCgoK", + "subType": "00" + } + }, + "size": 0, + "order": 2, + "_class": "cn.violin.home.book.entity.BlogInfo", + "owner": "3272499474" +},{ + "_id": { + "$oid": "635741bd4d5e3e71fb66a654" + }, + "bid": "2022102509540400000000000001", + "title": "10. 线性回归分析和方差分析", + "btId": "2022102117130200000000000002", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "order": 5, + "_class": "cn.violin.home.book.entity.BlogInfo", + "owner": "3272499474" +},{ + "_id": { + "$oid": "636b0c4586a27114103f7e20" + }, + "bid": "2022110910113500000000000002", + "owner": "3272499474", + "title": "pvc", + "btId": "2022052309468900000000000004", + "content": { + "$binary": { + "base64": "", + "subType": "00" + } + }, + "size": 0, + "order": 7, + "_class": "cn.violin.home.book.entity.BlogInfo" +},{ + "_id": { + "$oid": "6385b66e6f0a7030d5f44209" + }, + "bid": "2022112915369100000000000001", + "owner": "3272499474", + "title": "第三章 线性模型", + "btId": "2022102117088800000000000001", + "content": { + "$binary": { + "base64": "## 3.1 基本模型（linear model）
---
给定由 $d$ 个属性描述得实例 ${\pmb{x}}$ $  = (x_{1}; x_{2};...; x_{d})$，其中$x_i$ 是 ${\pmb{x}}$ 在第 $i$ 个属性山对的取值。  
线性模型试图学得一个通过属性的 **线性组合** 来进行 预测的函数，即
$$
f(x) = w_1x_1 + w_2x_2 + ... + w_3x_3 + b , \tag{3.1}
$$
  
一般用向量表示，写成  
$$
f(x) = \pmb{w}^{\pmb{T}}\pmb{x} + b, \tag{3.2}
$$
其中${\pmb{w}}$ $  = (w_{1}; w_{2};...; w_{d})$。${\pmb{w}}$和b学得之后，模型就得以确定。

`※注意`  
`行向量用 "," ，而列向量用 ";"`

## 3.2 线性回归（linear regression）
给定数据集$D = \{ (x_1, y_1), (x_1, y_1), ... (x_m, y_m) \}$，其中 $\pmb{x}_i = (x_{i1}; x_{i2};...; x_{id})$，$y_i \in R$。  
线性回归 试图学习得一个线性模型，来尽可能准确的预测真实值输出标记label。
$$
f(x_i) = \pmb{w}^{\pmb{T}}\pmb{x_i} + b, \text{ 使得} f(x_i) \simeq y_i
 \tag{3.3}
$$

如何确定 $w$ 和 $b$ 呢，通过2.3节的介绍过，均方误差(2.2)是回归任务中最常用的性能度量，因此我们试图让均方误差最小化。即，最小二乘法。  
即
$$
(w^*, b*) = arg\,min \sum_{i=1}^{m} (f(x_i) - y_i)^2
$$
$$
= arg\,min \sum_{i=1}^{m} (y_i - wx_i -b)^2
$$
$$
= arg\,min \sum_{i=1}^{m} [(y_i-b)^2 + w^2x_i^2 - 2wx_iy_i]
$$
$$
= arg\,min \sum_{i=1}^{m} [(y_i-b)^2 + w^2x_i^2 - 2wx_iy_i]
$$

均方误差有非常好的几何意义，他应对了常用的欧几里得几何定理。

而对于多元线性回归，我们把 $\pmb{w}$ 和 $b$ 吸收入向量形式 $\hat{ \pmb{w} } = (\pmb{w};b)$， 即 $\hat{ \pmb{w} } = (w_1;w_2;...;w_d;b)$，即 d + 1 列。  
对于数据集$D$，我们将它表示为一个 $m \times (d + 1)$ 大小矩阵 $ X $，用以方便进行 $ \pmb{w}^{\pmb{T}}\pmb{x} + b$ 相乘。
$$
\pmb{X}=\begin{pmatrix} 
x_{11} & x_{12} & \cdots & x_{1d} & 1\\
x_{21} & x_{22} & \cdots & x_{2d} & 1\\
\vdots & \vdots & \ddots & \vdots & 1\\
x_{m1} & x_{m2} & \cdots & x_{md} & 1\\ 
\end{pmatrix} = \begin{pmatrix}
\pmb{x}_{1}^T  & 1\\
\pmb{x}_{2}^T  & 1\\
\vdots  & 1\\
\pmb{x}_{m}^T  & 1\\ 
\end{pmatrix}
$$
注意，这里的 $\pmb{x}_i$ 是列向量，转置后就是行向量了。
这样
$$
 \pmb{X}\hat{ \pmb{w} } = \begin{pmatrix} 
x_{11} & x_{12} & \cdots & x_{1d} & 1\\
x_{21} & x_{22} & \cdots & x_{2d} & 1\\
\vdots & \vdots & \ddots & \vdots & 1\\
x_{m1} & x_{m2} & \cdots & x_{md} & 1\\ 
\end{pmatrix}\begin{pmatrix}
w_{1} \\
w_{2} \\
\vdots \\
w_{d} \\ 
b \\ 
\end{pmatrix} = \begin{pmatrix}
\pmb{x}_{1}^T  & 1\\
\pmb{x}_{2}^T  & 1\\
\vdots  & 1\\
\pmb{x}_{m}^T  & 1\\ 
\end{pmatrix}\begin{pmatrix}
\pmb{w} \\
b \\ 
\end{pmatrix} 
$$

再把标记也写成向量形式 $y = (y_1;y_2;...;y_m)$, 有
$$
\hat{\pmb{w}}^* = arg \, min (\pmb{y} - \pmb{X} \hat{\pmb{w}})^T(\pmb{y} - \pmb{X} \hat{\pmb{w}}) \tag{3.9}
$$
令 $E_{\hat{w}} = (\pmb{y} - \pmb{X} \hat{\pmb{w}})^T(\pmb{y} - \pmb{X} \hat{\pmb{w}})$, 对 $\hat{ \pmb{w} }$ 求导得到
$$
\frac{\partial E_{\hat{w}}}{\partial \hat{\pmb{w}}} = 2 \, \pmb{X}^T(\pmb{X}\hat{\pmb{w}} -\pmb{y}) \tag{3.10}
$$
令上式为0，可得 $\hat{ \pmb{w} }$ 最优解的闭式解

`※闭式解也被称为解析解，是通过严格的公式所求得的解，即包含分式、三角函数、指数、对数甚至无限级数等基本函数的解的形式。通过给出解的具体函数形式，从解的表达式中就可以算出任何对应值。`

当 $\pmb{X}^T \pmb{X}$ 为满秩矩阵，可以直接令(3.10)为零即可得，
$$
\hat{\pmb{w}}^* = (\pmb{X}^T \pmb{X})^{-1}\pmb{X}\pmb{y}
$$
其中，$\pmb{X}^T \pmb{X})^{-1}$ 是矩阵 $\pmb{X}^T \pmb{X}$ 的逆矩阵。令$\hat{\pmb{x}}_i = (\pmb{x}_i; 1)$ 最终学得多元线性回归模型为
$$
f(\hat{\pmb{x}}_i) = {\hat{\pmb{x}}_i}^T(\pmb{X}^T \pmb{X})^{-1}\pmb{X}\pmb{y}
$$

然后现实任务中，$\pmb{X}^T \pmb{X}$ 并不是满秩矩阵，例如在许多学习任务中我们会遇到大量的参数，其数量甚至超过样例数，导致 $\pmb{X}$ 列数多于行数，此时 $\pmb{X}^T \pmb{X}$ 显然不是满秩矩阵。  
此时可解出 $\hat{ \pmb{w} }$ , 他们都能是均方误差最小化，选择哪一个解作为输出将由学习算法的归纳偏好决定，常见的作法，就是**引入正则化项**(**regularization**)。

线性模型虽然简单，但是却有着丰富的变化，最简单就是将标记对数化，即将输出标记的对数作为线性模型逼近的目标
$$
\ln y = \pmb{w}^T \pmb{x} + b \tag{3.14}
$$
这就是 对数线性回归（log-linear regression），它实际上在试图让 $e^{\pmb{w}^T \pmb{x} + b}$逼近 $y$。(3.14) 在形式上仍是**线性回归**(linear regression), 但实质上是输入空间到输出空间的非线性的函数映射。

更一般的，考虑单调可微函数 $g(\cdot)$ ，令
$$
y = g^{-1}(\pmb{w}^T \pmb{x} + b) \tag{3.15}
$$ 

这样就得到了 **广义线性模型** (**generalized linear model**) ，其中函数 $g(\cdot)$ 称为 **联系函数** (**link function**)。

## 3.3 对数几率回归

在第一章介绍过，我们知道预测的结果为离散的，我们称为分类(classification)任务，预测的结果是连续的，我们成为回归(regression)任务。  
上一节讨论了线性模型进行回归学习，但是若要做分类任务怎么办呢？答案蕴含在(3.15)的广义线性模型中：只需要找到一个单调可微函数将分类任务的真实标记 $y$ 与线性回归模型的预测值联系起来。

我们先考虑二分类任务（binary classification），其输出标记 $y \in \{ 0, 1 \}$，而线性回归模型产生的预测值是 $ z = \pmb{w}^T\pmb{x} + b$ 是实值，于是我们需要通过将 $z$ 转换为 0/1 的值。  
而最理想是 **单位阶跃函数**（unit-step function）
$$
f(n)= 
\begin{cases} 
0, & \text {$z < 0$} \\ 
0.5, & \text {$z = 0$} \\ 
1, & \text{$z > 0$} 
\end{cases} \tag{3.16}
$$

单位阶跃函数不连续，不能作为 $g(\cdot)$ 的 反函数使用。于是我们希望，找到一个在一定程度近似于单位阶跃函数的代替函数，并希望他单调可微。**对数几率函数**（logistic function）正是这样的一个常用的替代函数。
$$
y = \frac{1}{1 + e^{-z}} \tag{3.17}
$$
将 $ z = \pmb{w}^T\pmb{x} + b$ 带入3.17中得到
$$
y = \frac{1}{1 + e^{-(\pmb{w}^T\pmb{x} + b)}} \tag{3.18}
$$
类似于3.14，对上式取对数，可变化为
$$
ln \frac{y}{1-y} = \pmb{w}^T\pmb{x} + b \tag{3.19}
$$

若将 $y$ 视为样本 $x$ 为正例的可能性，那么 $1-y$则是反例可能性，两者的比值 
$$
\frac{y}{1-y} \tag{3.20}
$$
称为 **几率**（odds），反映了 $x$ 为了正例的相对可能性，对几率取对数则得到 **对数几率**（log odds，或者logit）
$$
\ln\frac{y}{1-y} \tag{3.21}
$$
可以看出（3.18）实际上在用线性回归模型的预测结果去逼近真是标记的对数几率，因此，此模型称为 **对数几率模型** （logistic regression 或者 logit regression）  

下面我们来看看如何确定式(3.18)中的 $\pmb{w}$ 和 $b$.若将y视为后验概率估计 $p(y=1|x)$,则式(3.19)可重写为
$$
ln \frac{p(y=1|x)}{p(y=0|x)} = \pmb{w}^T\pmb{x} + b \tag{3.22}
$$
显然有
$$
p(y=1|x) = \frac{e^{\pmb{w}^T\pmb{x} + b}}{1 + e^{\pmb{w}^T\pmb{x} + b}} \tag{3.23}
$$
$$
p(y=0|x) = \frac{1}{1 + e^{\pmb{w}^T\pmb{x} + b}} \tag{3.24}
$$
于是，我们通过极大似然估计来估计$\pmb{w}$ 和 $b$.给定数据集$\{ (x_i, y_i) \}_{i=1}^m$,对数几率回归模型最大化"对数似然"

$$
\ell(\pmb{w}, b) = \sum_{i=1}^{m} p(y_i| \pmb{x_i};\pmb{w},b)  \tag{3.25}
$$




## 3.4 线性判断分析

## 3.5 多分类学习

## 3.6 类别不平衡问题

", + "subType": "00" + } + }, + "size": 0, + "order": 2, + "_class": "cn.violin.home.book.entity.BlogInfo" +},{ + "_id": { + "$oid": "6392e15625fc64427d89cb49" + }, + "bid": "2022120915183100000000000001", + "owner": "3272499474", + "title": "Spring superinterface", + "btId": "00000000000002", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "order": 8, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "639ab5f925fc64427d89cb4a" + }, + "bid": "2022121513519200000000000002", + "owner": "3272499474", + "title": "Springboot DefaultSingletonBeanRegistry", + "btId": "00000000000002", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "order": 4, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "639ab7de25fc64427d89cb4b" + }, + "bid": "2022121513597200000000000003", + "owner": "3272499474", + "title": "Springboot SpringApplication", + "btId": "00000000000002", + "content": { + "$binary": { + "base64": "IyMgU3ByaW5nQXBwbGljYXRpb24KCiMjIHguMSBwcm9wZXJ0aWVzCgojIyMgc291cmNlcwoKIyMjIGVudmlyb25tZW50CgojIyMgd2ViQXBwbGljYXRpb25UeXBlCgojIyMgCgojIyB4LjIgbWV0aG9kcwoKIyMjIHJ1bgoKMS4g5Yib5bu6IERlZmF1bHRCb290c3RyYXBDb250ZXh0IAoyLiDojrflj5YgU3ByaW5nQXBwbGljYXRpb25SdW5MaXN0ZW5lcnMKMy4g6L2s5o2iIEFwcGxpY2F0aW9uQXJndW1lbnRzIOWwhmNvbW1hbmRMaW5lIGFyZ3MgCjQuIOijheWkh+eOr+WigyBDb25maWd1cmFibGVFbnZpcm9ubWVudAo1LiDphY3nva7lv73nlaViZWFu5oOF5oqlIGNvbmZpZ3VyZUlnbm9yZUJlYW5JbmZvCjYuIOWIm+W7uiBBcHBsaWNhdGlvbkNvbnRleHQKNy4g5YeG5aSHIEFwcGxpY2F0aW9uQ29udGV4dCBwcmVwYXJlQ29udGV4dArorr7nva7kuIrkuIvmlofnjq/looPvvIzliqDovb1zb3VyY2UKOC4g5Yi35pawIEFwcGxpY2F0aW9uQ29udGV4dAo5LiDliLfmlrDlkI7lpITnkIYg", + "subType": "00" + } + }, + "size": 0, + "order": 0, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "639acd6f25fc64427d89cb4c" + }, + "bid": "2022121515315000000000000004", + "owner": "3272499474", + "title": "Springboot AbstractBeanFactory", + "btId": "00000000000002", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "order": 2, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "639b3da225fc64427d89cb4d" + }, + "bid": "2022121523309700000000000005", + "owner": "3272499474", + "title": "Springboot AbstractAutowireCapableBeanFactory", + "btId": "00000000000002", + "content": { + "$binary": { + "base64": "IyMgQWJzdHJhY3RBdXRvd2lyZUNhcGFibGVCZWFuRmFjdG9yeQoK54i257G75pivQWJzdHJhY3RCZWFuRmFjdG9yee+8jOWunueOsOS6hkF1dG93aXJlQ2FwYWJsZUJlYW5GYWN0b3J5IOeahOaWueazle+8jOWFtuS4reacgOS4u+imgeeahOi/mOaYr2NyZWF0ZUJlYW7mlrnms5XjgIIK5rqQ56CBCgoJLyoqCgkgKiBDZW50cmFsIG1ldGhvZCBvZiB0aGlzIGNsYXNzOiBjcmVhdGVzIGEgYmVhbiBpbnN0YW5jZSwKCSAqIHBvcHVsYXRlcyB0aGUgYmVhbiBpbnN0YW5jZSwgYXBwbGllcyBwb3N0LXByb2Nlc3NvcnMsIGV0Yy4KCSAqIEBzZWUgI2RvQ3JlYXRlQmVhbgoJICovCglAT3ZlcnJpZGUKCXByb3RlY3RlZCBPYmplY3QgY3JlYXRlQmVhbihTdHJpbmcgYmVhbk5hbWUsIFJvb3RCZWFuRGVmaW5pdGlvbiBtYmQsIEBOdWxsYWJsZSBPYmplY3RbXSBhcmdzKQoJCQl0aHJvd3MgQmVhbkNyZWF0aW9uRXhjZXB0aW9uIHsKCgkJaWYgKGxvZ2dlci5pc1RyYWNlRW5hYmxlZCgpKSB7CgkJCWxvZ2dlci50cmFjZSgiQ3JlYXRpbmcgaW5zdGFuY2Ugb2YgYmVhbiAnIiArIGJlYW5OYW1lICsgIiciKTsKCQl9CgkJUm9vdEJlYW5EZWZpbml0aW9uIG1iZFRvVXNlID0gbWJkOwoKCQkvLyBNYWtlIHN1cmUgYmVhbiBjbGFzcyBpcyBhY3R1YWxseSByZXNvbHZlZCBhdCB0aGlzIHBvaW50LCBhbmQKCQkvLyBjbG9uZSB0aGUgYmVhbiBkZWZpbml0aW9uIGluIGNhc2Ugb2YgYSBkeW5hbWljYWxseSByZXNvbHZlZCBDbGFzcwoJCS8vIHdoaWNoIGNhbm5vdCBiZSBzdG9yZWQgaW4gdGhlIHNoYXJlZCBtZXJnZWQgYmVhbiBkZWZpbml0aW9uLgoJCUNsYXNzPD8+IHJlc29sdmVkQ2xhc3MgPSByZXNvbHZlQmVhbkNsYXNzKG1iZCwgYmVhbk5hbWUpOwoJCWlmIChyZXNvbHZlZENsYXNzICE9IG51bGwgJiYgIW1iZC5oYXNCZWFuQ2xhc3MoKSAmJiBtYmQuZ2V0QmVhbkNsYXNzTmFtZSgpICE9IG51bGwpIHsKCQkJbWJkVG9Vc2UgPSBuZXcgUm9vdEJlYW5EZWZpbml0aW9uKG1iZCk7CgkJCW1iZFRvVXNlLnNldEJlYW5DbGFzcyhyZXNvbHZlZENsYXNzKTsKCQl9CgoJCS8vIFByZXBhcmUgbWV0aG9kIG92ZXJyaWRlcy4KCQl0cnkgewoJCQltYmRUb1VzZS5wcmVwYXJlTWV0aG9kT3ZlcnJpZGVzKCk7CgkJfQoJCWNhdGNoIChCZWFuRGVmaW5pdGlvblZhbGlkYXRpb25FeGNlcHRpb24gZXgpIHsKCQkJdGhyb3cgbmV3IEJlYW5EZWZpbml0aW9uU3RvcmVFeGNlcHRpb24obWJkVG9Vc2UuZ2V0UmVzb3VyY2VEZXNjcmlwdGlvbigpLAoJCQkJCWJlYW5OYW1lLCAiVmFsaWRhdGlvbiBvZiBtZXRob2Qgb3ZlcnJpZGVzIGZhaWxlZCIsIGV4KTsKCQl9CgoJCXRyeSB7CgkJCS8vIEdpdmUgQmVhblBvc3RQcm9jZXNzb3JzIGEgY2hhbmNlIHRvIHJldHVybiBhIHByb3h5IGluc3RlYWQgb2YgdGhlIHRhcmdldCBiZWFuIGluc3RhbmNlLgoJCQlPYmplY3QgYmVhbiA9IHJlc29sdmVCZWZvcmVJbnN0YW50aWF0aW9uKGJlYW5OYW1lLCBtYmRUb1VzZSk7CgkJCWlmIChiZWFuICE9IG51bGwpIHsKCQkJCXJldHVybiBiZWFuOwoJCQl9CgkJfQoJCWNhdGNoIChUaHJvd2FibGUgZXgpIHsKCQkJdGhyb3cgbmV3IEJlYW5DcmVhdGlvbkV4Y2VwdGlvbihtYmRUb1VzZS5nZXRSZXNvdXJjZURlc2NyaXB0aW9uKCksIGJlYW5OYW1lLAoJCQkJCSJCZWFuUG9zdFByb2Nlc3NvciBiZWZvcmUgaW5zdGFudGlhdGlvbiBvZiBiZWFuIGZhaWxlZCIsIGV4KTsKCQl9CgoJCXRyeSB7CgkJCU9iamVjdCBiZWFuSW5zdGFuY2UgPSBkb0NyZWF0ZUJlYW4oYmVhbk5hbWUsIG1iZFRvVXNlLCBhcmdzKTsKCQkJaWYgKGxvZ2dlci5pc1RyYWNlRW5hYmxlZCgpKSB7CgkJCQlsb2dnZXIudHJhY2UoIkZpbmlzaGVkIGNyZWF0aW5nIGluc3RhbmNlIG9mIGJlYW4gJyIgKyBiZWFuTmFtZSArICInIik7CgkJCX0KCQkJcmV0dXJuIGJlYW5JbnN0YW5jZTsKCQl9CgkJY2F0Y2ggKEJlYW5DcmVhdGlvbkV4Y2VwdGlvbiB8IEltcGxpY2l0bHlBcHBlYXJlZFNpbmdsZXRvbkV4Y2VwdGlvbiBleCkgewoJCQkvLyBBIHByZXZpb3VzbHkgZGV0ZWN0ZWQgZXhjZXB0aW9uIHdpdGggcHJvcGVyIGJlYW4gY3JlYXRpb24gY29udGV4dCBhbHJlYWR5LAoJCQkvLyBvciBpbGxlZ2FsIHNpbmdsZXRvbiBzdGF0ZSB0byBiZSBjb21tdW5pY2F0ZWQgdXAgdG8gRGVmYXVsdFNpbmdsZXRvbkJlYW5SZWdpc3RyeS4KCQkJdGhyb3cgZXg7CgkJfQoJCWNhdGNoIChUaHJvd2FibGUgZXgpIHsKCQkJdGhyb3cgbmV3IEJlYW5DcmVhdGlvbkV4Y2VwdGlvbigKCQkJCQltYmRUb1VzZS5nZXRSZXNvdXJjZURlc2NyaXB0aW9uKCksIGJlYW5OYW1lLCAiVW5leHBlY3RlZCBleGNlcHRpb24gZHVyaW5nIGJlYW4gY3JlYXRpb24iLCBleCk7CgkJfQoJfQ==", + "subType": "00" + } + }, + "size": 0, + "order": 3, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "639b3ee225fc64427d89cb4e" + }, + "bid": "2022121523361800000000000006", + "owner": "3272499474", + "title": "Springboot AbstractBeanDefinition", + "btId": "00000000000002", + "content": { + "$binary": { + "base64": "IyMgQWJzdHJhY3RCZWFuRGVmaW5pdGlvbgoKQWJzdHJhY3RCZWFuRGVmaW5pdGlvbiDlrprkuYnkuoYg5LiA5LiqYmVhbueahOWQhOenjeaPj+i/sOOAggoKIyMgeC4xCgojIyMgU3RyaW5nW10gZGVwZW5kc09uCgojIyMgUmVzb3VyY2UgcmVzb3VyY2UKCiMjIyA=", + "subType": "00" + } + }, + "size": 0, + "order": 5, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "639bc85225fc64427d89cb50" + }, + "bid": "2022121609222900000000000008", + "owner": "3272499474", + "title": "网关（gateway）", + "btId": "00000000000004", + "content": { + "$binary": { + "base64": "aHR0cHM6Ly9iaXByb2d5LmJveC5jb20vcy9lMmsyNms3OHVoZDJ4NHlvNHNramZnaHAweTdpcGMydwoKaHR0cHM6Ly9hcHAuYm94Y24ubmV0L2ZvbGRlcgo=", + "subType": "00" + } + }, + "size": 0, + "order": 3, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "639bf40225fc64427d89cb51" + }, + "bid": "2022121612282000000000000009", + "owner": "3272499474", + "title": "Springboot ConfigurationClassPostProcessor", + "btId": "00000000000002", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "order": 6, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "639c1f3325fc64427d89cb52" + }, + "bid": "2022121615335100000000000010", + "owner": "3272499474", + "title": "Spring ASM", + "btId": "00000000000002", + "content": { + "$binary": { + "base64": "IyMgYXNtIAoK5Zyoc3ByaW5n5Lit5YW25a6e5b6I5bCR5ZCs5YiwYXNt6L+Z5Liq5YWz6ZSu5a2X77yMYXNtIC0+IEFzc2VtYmx577yM6Lef5aSa5piv5oyH5rGH57yW6K+t6KiA44CCCgpzcHJpbmfkuZ/mmK/nlKjliLBhc23vvIzogIzkuJRhc23ljIXmmK9zcHJpbmctY29yZeeahOe7hOaIkOmDqOWIhuOAgnNwcmluZyBhc20g5aSn5L2T5LiK6LefIOWOn+eUn+eahGFzbSDpg73mmK/lt67kuI3lpJrkuobjgIIKCu+8iOWPgueFp+mTvuaOpSlbIGh0dHBzOi8vZG9jcy5zcHJpbmcuaW8vc3ByaW5nLWZyYW1ld29yay9kb2NzL2N1cnJlbnQvamF2YWRvYy1hcGkvb3JnL3NwcmluZ2ZyYW1ld29yay9hc20vcGFja2FnZS1zdW1tYXJ5Lmh0bSBdCgoKICAgIHBhY2thZ2Ugb3JnLnNwcmluZ2ZyYW1ld29yay5hc20KICAgIFNwcmluZydzIHJlcGFja2FnaW5nIG9mIEFTTSA5LnggKHdpdGggU3ByaW5nLXNwZWNpZmljIHBhdGNoZXM7IGZvciBpbnRlcm5hbCB1c2Ugb25seSkuCiAgICBUaGlzIHJlcGFja2FnaW5nIHRlY2huaXF1ZSBhdm9pZHMgYW55IHBvdGVudGlhbCBjb25mbGljdHMgd2l0aCBkZXBlbmRlbmNpZXMgb24gQVNNIGF0IHRoZSBhcHBsaWNhdGlvbiBsZXZlbCBvciBmcm9tIHRoaXJkLXBhcnR5IGxpYnJhcmllcyBhbmQgZnJhbWV3b3Jrcy4KICAgIAogICAgQXMgdGhpcyByZXBhY2thZ2luZyBoYXBwZW5zIGF0IHRoZSBjbGFzcyBmaWxlIGxldmVsLCBzb3VyY2VzIGFuZCBqYXZhZG9jcyBhcmUgbm90IGF2YWlsYWJsZSBoZXJlLgoK5LuOcGFja2FnZS1pbmZv5Y+v5Lul55yL5Ye677yMcmVwYWNrYWdpbmfvvIxhdm9pZHMgYW55IHBvdGVudGlhbCBjb25mbGljdHMg", + "subType": "00" + } + }, + "size": 0, + "order": 9, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "63a0185b25fc64427d89cb53" + }, + "bid": "2022121915527600000000000011", + "owner": "3272499474", + "title": "PostProcessorRegistrationDelegate", + "btId": "00000000000002", + "content": { + "$binary": { + "base64": "IyMgUG9zdFByb2Nlc3NvclJlZ2lzdHJhdGlvbkRlbGVnYXRlCgrkvZzkuLogRGVsZWdhdGUg5o+Q5L6b5LqGIOmdmeaAgeaWueazlSBpbnZva2VCZWFuRmFjdG9yeVBvc3RQcm9jZXNzb3Jz44CCCgrkuLvopoHmmK/lsIZiZWFuRmFjdG9yeeWSjGJlYW5GYWN0b3J5UG9zdFByb2Nlc3NvcnPlgZptYXRjaGluZ++8jArnhLblkI7lr7liZWFuRmFjdG9yeVBvc3RQcm9jZXNzb3Jz5YGa6YGN5Y6G6LCD55SocG9zdFByb2Nlc3NCZWFuRmFjdG9yeShiZWFuRmFjdG9yeSkKCiMjIENvbmZpZ3VyYXRpb25DbGFzc1Bvc3RQcm9jZXNzb3IKCnBvc3RQcm9jZXNzQmVhbkZhY3RvcnkoYmVhbkZhY3RvcnkpCgpwcm9jZXNzQ29uZmlnQmVhbkRlZmluaXRpb25zKGJlYW5GYWN0b3J5KQoK5qC45b+D55qEIOWkhOeQhuaWueazle+8jA==", + "subType": "00" + } + }, + "size": 0, + "order": 7, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "63aaa5fb25fc64427d89cb54" + }, + "bid": "2022122715594900000000000012", + "owner": "3272499474", + "title": "Spring Aop", + "btId": "00000000000002", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "order": 13, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "63abba2725fc64427d89cb55" + }, + "bid": "2022122811384800000000000013", + "owner": "3272499474", + "title": "为什么JDK动态代理只能代理接口", + "btId": "2022050622313300000000000022", + "content": { + "$binary": { + "base64": "5Li65LuA5LmISkRL5Yqo5oCB5Luj55CG5Y+q6IO95Luj55CG5o6l5Y+j77yM5LiN6IO955u05o6l5Luj55CG57G777yfQ0dsaWLkuLrku4DkuYjlj6/ku6Xku6PnkIbnsbvvvJ8KCuWKqOaAgeS7o+eQhueUn+aIkOeahFByb3h5XCQw57G75piv57un5om/5LqGUHJveHnnsbvlubbkuJRpbXBsZW1lbnRz5Luj55CG5o6l5Y+j77yM5L2G55Sx5LqOamF2YeaYr+S4jeiDveWkmue7p+aJv+eahO+8jOaJgOS7peWKqOaAgeS7o+eQhuS4jeiDveS7o+eQhuexu+OAggoKY2dsaWLlrp7njrDliqjmgIHku6PnkIbnmoTpgLvovpHmmK/kvb/nlKjlrZDnsbvnu6fmib/ku6PnkIbnsbvvvIzlsLHmsqHmnInljZXnu6fmib/nmoTpmZDliLbkuoYu", + "subType": "00" + } + }, + "size": 0, + "order": 3, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "63c62d598f766e5682ba96d0" + }, + "bid": "2023011713085500000000000001", + "owner": "3272499474", + "title": "第四章 决策树", + "btId": "2022102117088800000000000001", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "order": 3, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "63c689df8f766e5682ba96d1" + }, + "bid": "2023011719438400000000000002", + "owner": "3272499474", + "title": "第五章 神经网络", + "btId": "2022102117088800000000000001", + "content": { + "$binary": { + "base64": "6K+l5YaZ54K55LuA5LmI5LmILi4u", + "subType": "00" + } + }, + "size": 0, + "order": 4, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "63c68a0b8f766e5682ba96d2" + }, + "bid": "2023011719441300000000000003", + "owner": "3272499474", + "title": "第六章 支持向量机", + "btId": "2022102117088800000000000001", + "content": { + "$binary": { + "base64": "6K+l5YaZ54K55LuA5LmI5LmILi4u", + "subType": "00" + } + }, + "size": 0, + "order": 5, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "63c68a188f766e5682ba96d3" + }, + "bid": "2023011719441200000000000004", + "owner": "3272499474", + "title": "第七章 贝叶斯分类器", + "btId": "2022102117088800000000000001", + "content": { + "$binary": { + "base64": "6K+l5YaZ54K55LuA5LmI5LmILi4u", + "subType": "00" + } + }, + "size": 0, + "order": 6, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "63c68a358f766e5682ba96d4" + }, + "bid": "2023011719447400000000000005", + "owner": "3272499474", + "title": "第八章 集成学习", + "btId": "2022102117088800000000000001", + "content": { + "$binary": { + "base64": "6K+l5YaZ54K55LuA5LmI5LmILi4u", + "subType": "00" + } + }, + "size": 0, + "order": 7, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "63c68a468f766e5682ba96d5" + }, + "bid": "2023011719454000000000000006", + "owner": "3272499474", + "title": "第九章 聚类", + "btId": "2022102117088800000000000001", + "content": { + "$binary": { + "base64": "6K+l5YaZ54K55LuA5LmI5LmILi4u", + "subType": "00" + } + }, + "size": 0, + "order": 8, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "63c68a598f766e5682ba96d6" + }, + "bid": "2023011719451200000000000007", + "owner": "3272499474", + "title": "第十章 降维与度量学习", + "btId": "2022102117088800000000000001", + "content": { + "$binary": { + "base64": "6K+l5YaZ54K55LuA5LmI5LmILi4u", + "subType": "00" + } + }, + "size": 0, + "order": 9, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "63c68a788f766e5682ba96d7" + }, + "bid": "2023011719464700000000000008", + "owner": "3272499474", + "title": "第十一章 特征选择与稀疏学习", + "btId": "2022102117088800000000000001", + "content": { + "$binary": { + "base64": "6K+l5YaZ54K55LuA5LmI5LmILi4u", + "subType": "00" + } + }, + "size": 0, + "order": 10, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "63c68a8c8f766e5682ba96d8" + }, + "bid": "2023011719468000000000000009", + "owner": "3272499474", + "title": "第十二章 计算学习理论", + "btId": "2022102117088800000000000001", + "content": { + "$binary": { + "base64": "6K+l5YaZ54K55LuA5LmI5LmILi4u", + "subType": "00" + } + }, + "size": 0, + "order": 11, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "63c68aa58f766e5682ba96d9" + }, + "bid": "2023011719460100000000000010", + "owner": "3272499474", + "title": "第十三章 半监督学习", + "btId": "2022102117088800000000000001", + "content": { + "$binary": { + "base64": "6K+l5YaZ54K55LuA5LmI5LmILi4u", + "subType": "00" + } + }, + "size": 0, + "order": 12, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "63c68ab28f766e5682ba96da" + }, + "bid": "2023011719469800000000000011", + "owner": "3272499474", + "title": "第十四章 概率图模型", + "btId": "2022102117088800000000000001", + "content": { + "$binary": { + "base64": "6K+l5YaZ54K55LuA5LmI5LmILi4u", + "subType": "00" + } + }, + "size": 0, + "order": 13, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "63c68ac18f766e5682ba96db" + }, + "bid": "2023011719472500000000000012", + "owner": "3272499474", + "title": "第十五章 规则学习", + "btId": "2022102117088800000000000001", + "content": { + "$binary": { + "base64": "6K+l5YaZ54K55LuA5LmI5LmILi4u", + "subType": "00" + } + }, + "size": 0, + "order": 14, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "63c68ae08f766e5682ba96dc" + }, + "bid": "2023011719475600000000000013", + "owner": "3272499474", + "title": "第十六章 强化学习", + "btId": "2022102117088800000000000001", + "content": { + "$binary": { + "base64": "6K+l5YaZ54K55LuA5LmI5LmILi4u", + "subType": "00" + } + }, + "size": 0, + "order": 15, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "63eb81a3f3eea8401859f542" + }, + "bid": "2023021420423600000000000018", + "owner": "3272499474", + "title": "自己紹介", + "btId": "00000000000004", + "content": { + "$binary": { + "base64": "5pys5pel44Gv6LK06YeN44Gq5pmC6ZaT44KS44GE44Gf44Gg44GN44GC44KK44GM44Go44GG44GU44GW44GE44G+44GZ44CCCgrjgqvjg7Pjgrfjg6fjgqbjgqTjgajnlLPjgZfjgb7jgZnjgILku4rlubQzNeats+OBp+OBmeOAggoK5Y2S5qWt44GX44Gf5aSn5a2m44Gv5Lit5Zu944Gu5p2x5YyX5aSn5a2m44Gn44GZ44GM44CB5aSn5a2m6Zmi55Sf44Gu5Ye66Lqr5aSn5a2m44Gv44Gk44GP44Gw5aSn5a2m44CB5bCC6ZaA44Gv44K344K544OG44Og5oOF5aCx5bel5a2m44Gn44GZ44CCCgrljZLmpa3lvozjgIEx5bm044G244KK44Gu5Zyf5pyo57O744Gu5LuV5LqL44Go5LiA5bm044G244KK44Gu6YeR6J6N55+l6K2Y5a2m57+S44KS44GX44G+44GX44Gf44CCMjAxN+W5tOOBi+OCiUlU44Gr6Lui6IG344CB44Gd44KM44GL44KJ5Ym156eR5oqA6KGT5Lya56S+44CB5pel5pys44OP44Kk44Ot44Oz5qCq5byP5Lya56S+44CBSUJN5qCq5byP5Lya56S+44Gu5LiJ56S+44Gn5YON44GN44G+44GX44Gf44CCCgrntYzpqJPjgZfjgZ/jg5fjg63jgrjjgqfjgq/jg4jjga8xMOWAi+S7peS4iuOBp+OAgeioreioiOOAgemWi+eZuuOAgeODhuOCueODiOOAgVBPQ+aknOiovOOBquOBqeOBruOBhOOBj+OBpOOBi+OBruODleOCp+ODvOOCuuOCguWPguWKoOOBl+OBvuOBl+OBn+OAggoK5b6X5oSP44Gq6ZaL55m66KiA6Kqe44GvSmF2YeOAgUpz44CBR2/jgIFrdWJlcm5ldGVz44Gn44GZ44CCCgpJQk3jgavlhaXnpL7lvozjgIHjg5Xjg6vjgrnjgr/jg4Pjgq/jgqjjg7Pjgrjjg4vjgqLjgIHjgrPjg7PjgrXjg6vjgr/jg7Pjg4jjgajjgqLjg7zjgq3jg4bjgq/jg4Hjg6PjgajjgZfjgabmtLvouo3jgZfjgabjgYrjgorjgb7jgZnjgIIKCuWOu+W5tOOBr+OCr+ODqeOCpuODieODjeOCpOODhuOCo+ODluOAgENLQeOAgOOBqOOAgEF6dXJlIElvdOOBruizh+agvOOCkuWPluOCiuOBvuOBl+OBn+OAggoK44GT44Gu57WM6aiT44KS44Gc44Gy5b6h56S+44Gn44KC55Sf44GL44GX44Gm44GE44GN44Gf44GE44Go6ICD44GI44Gm44GK44KK44G+44GZ44CCCgrjganjgYbjgZ7jgojjgo3jgZfjgY/jgYrpoZjjgYTjgYTjgZ/jgZfjgb7jgZnjgIIKCmh0dHBzOi8vdGVhbXMubWljcm9zb2Z0LmNvbS9sL21lZXR1cC1qb2luLzE5JTNhbWVldGluZ19OalJsTW1Fd04yUXROVFUxTXkwME0yUTNMV0V5TkRFdE9EQXlPREU1T1dGa09EQXklNDB0aHJlYWQudjIvMD9jb250ZXh0PSU3YiUyMlRpZCUyMiUzYSUyMmIyYzZkYTAwLWRlNjMtNGY2YS05MGVkLTE3ZTQ4YTFmNjRhMiUyMiUyYyUyMk9pZCUyMiUzYSUyMjUyZTY2NzVmLWQ5MDItNDkzOS1iNTNmLTZiNjlhYWJmZGYzNSUyMiU3ZAoKCg==", + "subType": "00" + } + }, + "size": 0, + "order": 4, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "63f71a39f3eea8401859f544" + }, + "bid": "2023022315484500000000000019", + "owner": "3272499474", + "title": "2. grpc health check", + "btId": "2023022315480800000000000001", + "content": { + "$binary": { + "base64": "IyMg", + "subType": "00" + } + }, + "size": 0, + "order": 1, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "63f71a3df3eea8401859f545" + }, + "bid": "2023022315480900000000000020", + "owner": "3272499474", + "title": "3. grpc xds", + "btId": "2023022315480800000000000001", + "content": { + "$binary": { + "base64": "6K+l5YaZ54K55LuA5LmI5LmILi4u", + "subType": "00" + } + }, + "size": 0, + "order": 3, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "63f71aabf3eea8401859f546" + }, + "bid": "2023022315507600000000000021", + "owner": "3272499474", + "title": "1. grpc protoc", + "btId": "2023022315480800000000000001", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "order": 0, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "640038bff3eea8401859f547" + }, + "bid": "2023030213489100000000000022", + "owner": "3272499474", + "title": "4. Go", + "btId": "2023022315480800000000000001", + "content": { + "$binary": { + "base64": "IyMgMS4g5qaC6L+wCuS4gOS6m+eugOWNleeahOamguW/teS7i+e7jeWPr+S7pemAmui/h+S4i+mdoue9keermeWtpuS5oOWIsOOAgiAgCltnb2xhbmcg6I+c6bif5pWZ56iLXShodHRwczovL3d3dy5ydW5vb2IuY29tL2dvL2dvLXR1dG9yaWFsLmh0bWwpCgojIyAyLiBwYWNrYWdlCgpnb2xhbmfnmoTljIXnrqHnkIbmqKHlvI/mmK/moJHlvaLnmoTvvIzlubbkuJTmnInku6XkuIvop4TnuqbvvJogIAoqKjEqKiAgCuagkeW9oue7k+aehOeahOagueiKgueCueaYr21haW7vvIzljbPpobnnm67moLnnm67lvZXjgIIgIAoqKjIqKiAgCuaWh+S7tuS4reeahOWMheWumuS5iSDkuIDlrprmmK/lkozor6Xmlofku7bmiYDlpITnmoTmlofku7blpLnnm7jlkIwgIAoqKjMqKgrmlofku7bkuK3lrprkuYnnmoTlh73mlbDvvIzlpoLmnpzmmK/lg4/kvZzkuLrnrKzkuInmlrnljIXlvJXnlKjvvIzlh73mlbDnmoTpppblrZfmr43lv4XpobvlpKflhpkKCiAgICAjIHZpb2xpbi1jb250cm9sbGVyIOW3peeoi+S4uuS+iyBodHRwczovL2dpdGh1Yi5jb20vc2ltcGxlMzIxdmlwL3Zpb2xpbi1jb250cm9sbGVyCiAgICBscwogICAgbWFpbi5nbyBjb250cm9sbGVyLmdvIGNvbnRyb2xsZXJfdGVzdC5nbyDpg73mmK8g5qC555uu5b2V5LiL55qE5paH5Lu277yM5omA5Lul5LuW5Lus55qEcGFja2FnZSDpg73mmK8gbWFpbgogICAg6K+35rOo5oSPIOWMhSDnmoTlkI3lrZflj6rog73mmK/or6Xmlofku7blpLnnmoTlkI3lrZfvvIzlubbkuI3ljIXmi6zniLbnuqfot6/lvoQKCioqNCDlvJXljIUqKiAgCuW8leWMhSDljIXmi6znrKzkuInmlrnljIUg5ZKMIOmhueebruiHquWumuS5ieWMhQrlnKhtb2TmqKHlvI/kuIvvvIznrKzkuInmlrnljIXlrZjlnKggXCRHT1BBVEgvcGtnL21vZArogIzoh6rlrprkuYnljIUg5byV5YWl55qE5pe25YCZ55u05o6l5LuO6YeH55SoIOmhueebruebuOWvuei3r+W+hOeahOaWueW8j+W8leWFpQogICAgICAKIyMgMy4g5Y+Y6YeP5LiO5oyH6ZKICgrlj5jph4/liIbkuLog5YC85Y+Y6YeP5ZKM5oyH6ZKI5Y+Y6YePCgojIyA0LiDlh73mlbAKCioqMS4gbWFpbigpKiog5Ye95pWwCgrnqIvluo/lhaXlj6Plh73mlbAKCioqMi4gaW5pdCgpKiog5Ye95pWwCgrmr4/kuIDkuKrmupDmlofku7bpg73lj6/ku6XljIXlkKvkuIDkuKppbml05Ye95pWw77yMaW5pdOaEj+S4uuWIneWni+WMlu+8jOS5n+ihqOaYjmluaXTlh73mlbDkvJrlnKhtYWlu5Ye95pWw5omn6KGM5LmL5YmN5omn6KGM44CCCgoqKjMuIGdvIGZ1bmMoKSoqIOWHveaVsAoK5bm25Y+R57yW56iLIOWNs+W8guatpQoKKio0LiBmdW5jKCkge30oKSoqIOWMv+WQjeWHveaVsAoK5Yy/5ZCN5Ye95pWw5Y+v5Lul6YCa6L+H5Y+Y6YeP5oyH5ZCR5Yy/5ZCN5Ye95pWw77yM5Y+v5Lul5Yy/5ZCN5Ye95pWw55u05o6l5omn6KGMCgogICAgLy8g5aOw5piO5LiA5Liq5Ye95pWw5Y+Y6YePCiAgICBmIDo9IGZ1bmMoKSBpbnQgewogICAgICByZXR1cm4gMQogICAgfQoKICAgIC8vIOiwg+eUqOWHveaVsAogICAgZigpCgogICAgLy8g5Lmf5Y+v5Lul55u05o6l5omn6KGM5Yy/5ZCN5Ye95pWwCiAgICBmdW5jKCkgaW50IHsKICAgICAgcmV0dXJuIDEKICAgIH0oKQoKKio1LiBmdW5jIHNhbXBsZSgpIGZ1bmMoKSBpbnQge30qKiDpgJrov4fljL/lkI3lh73mlbDlrp7njrDpl63ljIUKCiAgICBwYWNrYWdlIG1haW4KICAgIAogICAgaW1wb3J0ICJmbXQiCiAgICAKICAgIGZ1bmMgZ2V0U2VxdWVuY2UoKSBmdW5jKCkgaW50IHsKICAgICAgIGk6PTAKICAgICAgIHJldHVybiBmdW5jKCkgaW50IHsKICAgICAgICAgIGkrPTEKICAgICAgICAgcmV0dXJuIGkgIAogICAgICAgfQogICAgfQogICAgCiAgICBmdW5jIG1haW4oKXsKICAgICAgIC8qIG5leHROdW1iZXIg5Li65LiA5Liq5Ye95pWw77yM5Ye95pWwIGkg5Li6IDAgKi8KICAgICAgIG5leHROdW1iZXIgOj0gZ2V0U2VxdWVuY2UoKSAgCiAgICAKICAgICAgIC8qIOiwg+eUqCBuZXh0TnVtYmVyIOWHveaVsO+8jGkg5Y+Y6YeP6Ieq5aKeIDEg5bm26L+U5ZueICovCiAgICAgICBmbXQuUHJpbnRsbihuZXh0TnVtYmVyKCkpCiAgICAgICBmbXQuUHJpbnRsbihuZXh0TnVtYmVyKCkpCiAgICAgICBmbXQuUHJpbnRsbihuZXh0TnVtYmVyKCkpCiAgICAgICAKICAgICAgIC8qIOWIm+W7uuaWsOeahOWHveaVsCBuZXh0TnVtYmVyMe+8jOW5tuafpeeci+e7k+aenCAqLwogICAgICAgbmV4dE51bWJlcjEgOj0gZ2V0U2VxdWVuY2UoKSAgCiAgICAgICBmbXQuUHJpbnRsbihuZXh0TnVtYmVyMSgpKQogICAgICAgZm10LlByaW50bG4obmV4dE51bWJlcjEoKSkKICAgIH0=", + "subType": "00" + } + }, + "size": 0, + "order": 2, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "64119f97f3eea8401859f548" + }, + "bid": "2023031518364800000000000023", + "owner": "3272499474", + "title": "curl 详解", + "btId": "2022050410146100000000000003", + "content": { + "$binary": { + "base64": "IyMjIEhlYWRlcgoK5L2/55SoIC1IIOadpeS8oOmAkuWPguaVsAoKICAgIGN1cmwgLUggInRlbmFudElkPTMyMSIgLUggImF1dGhvcml6YXRpb249eHh4eDpYWHh4IiAKCiMjIyBNZXRob2QKCuS9v+eUqCAtWCDmnaXmjIflrprmlrnms5UKCiAgICBjdXJsIC1YIEdFVAoKIyMjIFVSTAoK5a+5dXJsIOi/m+ihjOa3u+WKoOWPjOW8leWPtwogICAgCiAgICBjdXJsICJ3d3cuYmFpZHUuY29tIgoKIyMjIGV4YW1wbGUKCiMjIyMgMS4gR2V0CiAgICBjdXJsIC1IICJhdXRob3JpemF0aW9uOlg6WFgiIC1IICJ0ZW5hbnRpZDpzc3NzcyIgLVggR0VUICJsb2NhbGhvc3Q6ODA4MC92aW9saW4tYXBpL2FwaS92MS9yZW1pbmRlcj9yZW1pbmRlcl9pZD14eHh4eHgiCgojIyMjIDIuIFBvc3QKCiAgICBjdXJsIC1IICJDb250ZW50LVR5cGU6IGFwcGxpY2F0aW9uL2pzb24iIC1IICJhdXRob3JpemF0aW9uOlg6WFgiIC1IICJ0ZW5hbnRpZDpzc3NzcyIgLVggUE9TVCAtZCAneyJ0aXRsZSI6Inh4eHh4IiwiaW5mbyI6Inh4eHh4eHh4eHh4eHgifScgImxvY2FsaG9zdDo4MDgwL3Zpb2xpbi1hcGkvYXBpL3YxL3JlbWluZGVyIgoKIyMjIOS9v+eUqOazqOaEjwoKLSBwb3dlcnNoZWxsIOS4reeahGN1cmwg5Y+q5piv5LiqYWxpc2Ug5LiN6YCC55SoCi0gd2luZG935LiL55qEY3VybCDkvJrlh7rnjrDnvJbnoIHpl67popjvvIzlsKTlhbYi5bm25LiN5Lya57yW56CBIOS8muWvvOiHtCDlkI7lj7Ag5Ye6546w5LiL5YiX6ZSZ6K+vCiAgICAKICAgICAgeyJlcnJvciI6ImludmFsaWQgY2hhcmFjdGVyICdcXCcnIGxvb2tpbmcgZm9yIGJlZ2lubmluZyBvZiB2YWx1ZSJ9ICAK", + "subType": "00" + } + }, + "size": 0, + "order": 4, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "6420624e3b154137c10a99c7" + }, + "bid": "2023032623183000000000000024", + "owner": "3272499474", + "title": "Route", + "btId": "2022050410146100000000000003", + "content": { + "$binary": { + "base64": "IyMjIOi3r+eUseihqAotLS0KYGlwIHJvdXRlYAoKICAgIGlwIHJvdXRlIOWFtuWunuaYr+ayoeacieS9k+eOsOe9keWFs+WtmOWcqOOAguaPj+i/sOeahOaYr+e9keWNoeWSjOebrueahGlw77yM5rqQaXDkuYvpl7TnmoTlhbPns7sKICAgIOm7mOiupCDnu4/ov4cgMTAuMC44LjEg6LWw6buY6K6k572R5Y2hZXRoMAogICAg5oSP5oCd5piv6K+077yM5LiL6Z2i6Lev55Sx6KaB5piv5Yy56YWN5LiN5Yiw55qE6K+d77yM5bCx5piv57uP6L+HMTAuMC44LjEg572R5YWz77yI572R5Y2h6K6+5aSHZXRoMO+8iQogICAg5Y67IDEwLjAuOC4wLzIyIOS5n+i1sCBldGgwIOe9keWNoe+8jOS9huaYr+a6kGlw5pivMTAuMC44LjEzCiAgICDlpoLmnpzmmK/ljrsxNzIuMTcuMC4wLzE2IOi1sCBkb2NrZXIw572R5Y2h77yM5rqQaXDmmK8xNzIuMTcuMC4xCiAgICBbcm9vdEBub2RlMiBkZXZdIyBpcCByb3V0ZQogICAgZGVmYXVsdCB2aWEgMTAuMC44LjEgZGV2IGV0aDAKICAgIDEwLjAuOC4wLzIyIGRldiBldGgwIHByb3RvIGtlcm5lbCBzY29wZSBsaW5rIHNyYyAxMC4wLjguMTMKICAgIDE2OS4yNTQuMC4wLzE2IGRldiBldGgwIHNjb3BlIGxpbmsgbWV0cmljIDEwMDIKICAgIDE3Mi4xNy4wLjAvMTYgZGV2IGRvY2tlcjAgcHJvdG8ga2VybmVsIHNjb3BlIGxpbmsgc3JjIDE3Mi4xNy4wLjEKICAgIAoKYHJvdXRlIC1uYAogICAgCiAgICByb3V0ZSAtbiDmm7TlpJrnmoTkvZPnjrDnnYBpcOWcsOWdgOeahOiuvue9rumXrumimO+8jAogICAg55u05o6l5Y+v5Lul55yL5Yiw6buY6K6k55qE572R5YWzZ2F0ZXdheeaYrzEwLjAuOC4x77yM6YCa6L+H5a2Q572R5o6p56CB77yM56Gu5a6a572R57uc5Zyw5Z2A77yM6K6/6ZeuMTAuMC44LjDnmoTnvZHlhbPmmK8wLjAuMC4wIOWNs++8jOWGhemDqOe9kee7nO+8jOS4jei1sOe9keWFs+OAggogICAgW3Jvb3RAbm9kZTIgZGV2XSMgcm91dGUgLW4KICAgIEtlcm5lbCBJUCByb3V0aW5nIHRhYmxlCiAgICBEZXN0aW5hdGlvbiAgICAgR2F0ZXdheSAgICAgICAgIEdlbm1hc2sgICAgICAgICBGbGFncyBNZXRyaWMgUmVmICAgIFVzZSBJZmFjZQogICAgMC4wLjAuMCAgICAgICAgIDEwLjAuOC4xICAgICAgICAwLjAuMC4wICAgICAgICAgVUcgICAgMCAgICAgIDAgICAgICAgIDAgZXRoMAogICAgMTAuMC44LjAgICAgICAgIDAuMC4wLjAgICAgICAgICAyNTUuMjU1LjI1Mi4wICAgVSAgICAgMCAgICAgIDAgICAgICAgIDAgZXRoMAogICAgMTY5LjI1NC4wLjAgICAgIDAuMC4wLjAgICAgICAgICAyNTUuMjU1LjAuMCAgICAgVSAgICAgMTAwMiAgIDAgICAgICAgIDAgZXRoMAogICAgMTcyLjE3LjAuMCAgICAgIDAuMC4wLjAgICAgICAgICAyNTUuMjU1LjAuMCAgICAgVSAgICAgMCAgICAgIDAgICAgICAgIDAgZG9ja2VyMAoKYGlwIGFkZHJgCgogICAgaW5ldOihqOekuuS4u+acuuWcsOWdgOWSjOaJgOWkhOe9kee7nOauteOAggogICAgMjogZXRoMDogPEJST0FEQ0FTVCxNVUxUSUNBU1QsVVAsTE9XRVJfVVA+IG10dSAxNTAwIHFkaXNjIG1xIHN0YXRlIFVQIGdyb3VwIGRlZmF1bHQgcWxlbiAxMDAwCiAgICAgICAgbGluay9ldGhlciA1Mjo1NDowMDozOTplYTpjNCBicmQgZmY6ZmY6ZmY6ZmY6ZmY6ZmYKICAgICAgICBpbmV0IDEwLjAuOC4xMy8yMiBicmQgMTAuMC4xMS4yNTUgc2NvcGUgZ2xvYmFsIGV0aDAKICAgICAgICAgICB2YWxpZF9sZnQgZm9yZXZlciBwcmVmZXJyZWRfbGZ0IGZvcmV2ZXIKICAgICAgICBpbmV0NiBmZTgwOjo1MDU0OmZmOmZlMzk6ZWFjNC82NCBzY29wZSBsaW5rIAogICAgICAgICAgIHZhbGlkX2xmdCBmb3JldmVyIHByZWZlcnJlZF9sZnQgZm9yZXZlcgoKYEZsYWdzIOagh+iusGAKICAgIAogICAgVe+8iHJvdXRlIGlzIHVw77yJ6K+l6Lev55Sx5piv5ZCv5Yqo55qECiAgICBI77yIdGFyZ2V0IGlzIGEgaG9zdO+8ieebruagh+aYr+S4gOWPsOS4u+acuu+8iGlw77yJCiAgICBH77yIdXNlIGdhdGV3YXnvvInpnIDopoHpgJrov4flpJbpg6jnmoTkuLvmnLrkvKDpgIHmlbDmja7ljIUKICAgIFLvvIhyZWluc3RhdGUgcm91dGUgZm9yIGR5bmFtaWMgcm91dGluZ++8ieS9v+eUqOWKqOaAgei3r+eUseaXtuaBouWkjei3r+eUseagh+iusAogICAgRO+8iGR5bmFtaWNhbGx5IGluc3RhbGxlZCBieSBkYWVtb24gb3IgcmVkaXJlY3TvvIkKICAgIOW3sue7j+eUseacjeWKoeWZqOaIlui9rHBvcnTlip/og73orr7nva7kuLrliqjmgIHot6/nlLEhICAgIAogICAgKHJlamVjdCByb3V0ZSnov5nkuKrot6/nlLHlsIbkuI3kvJrooqvmjqXlj5fvvIjnlKjmnaXnu4Tnu4fkuI3lronlhajnmoTnvZHmrrXvvIkKICAgIOazqO+8muaYvuekuui3r+eUseS/oeaBr+S7juS4iuWIsOS4i+aYr+S7juiMg+WbtOWkp+WIsOWwj+OAggoKYGlwIG5laWdoYAoKICAgIDEwLjAuOC4xIOi/meS4qmlw5Zyw5Z2A5a+56LGh55qE572R5Y2h5pivZXRoMOi/mOaciW1hY++8jOS9hue9keWNoeacrOecgee7keWumueahGlw5Zyw5Z2AMTAuMC44LjPvvIzlj4jlkoxpcCBhZGRy5LitIGxpbmsgc3JjIDEwLjAuOC4zIOS4gOagt+OAggogICAg6L+Z5qC35bCx6K+05piO5LqG5LiA5Liq6Zeu6aKY77yM5ZCM5LiA572R5q6155qE6K6/6Zeu77yM5piv5LiN6YCa6L+H572R5YWz55u05o6l6LWw572R5Y2h77yM5LiN5ZCM572R5q6177yM6ZyA6KaB6LWwMTAuMC44LjEgCiAgICBbcm9vdEBub2RlMyB+XSMgaXAgbmVpZ2gKICAgIDEwLjAuOC4xIGRldiBldGgwIGxsYWRkciBmZTplZTozMDozMDoyMDoyNiBSRUFDSEFCTEUKICAgICAKYGdhdGV3YXnvvJrmjIfnmoTmmK/ot6/nlLHpgJrov4flk6rkuKpnYXRld2F55Ye65Y67YApgR2F0ZXdheeaYrzAuMC4wLjDmiJbogIUq6KGo56S655uu5qCH5piv5pys5Li75py65omA5bGe55qE572R57ucLOS4jemcgOimgei3r+eUsWAKCgoKIyMjIHRha2UgaW4gYWN0aW9ucwotLS0=", + "subType": "00" + } + }, + "size": 0, + "order": 0, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "6420650c3b154137c10a99c8" + }, + "bid": "2023032623302100000000000025", + "owner": "3272499474", + "title": "Tptables概念", + "btId": "2022050410146100000000000003", + "content": { + "$binary": { + "base64": "IyMjIFRwdGFibGVz5qaC5b+1Ci0tLQpb5paw5omL5pWZ5a2mXShodHRwczovL3d3dy56c3l0aGluay5uZXQvYXJjaGl2ZXMvMTE5OSkKaXB0YWJsZXMgaXMgYSBwYWNrYWdlIGZpbHRlciBmaXJld2FsbCBmb3IgbGludXggc3lzdGVtLgoKaXB0YWJsZXMgY2FkIGRvIGJlbG9377yaCi0gZmlsdGVyIHBhY2thZ2Ug77yI5bCB5YyF6L+H5ruk77yJCi0gcGFja2FnZSByZWRpcmVjdCDvvIjlsIHljIXph43lrprlkJHvvIkKLSBuZXR3b3JrIGFkZHJlc3MgdHJhbnNsYXRpb24g77yI572R57uc5Zyw5Z2A6L2s5o2i77yJCgp0byBsZWFybiBpcHRhYmxlc++8jCB5b3Ugc2hvdWxkIHRvIHVuZGVyc3RhbmQgdGhlIGNvbmNlcHRzIG9mIGJlbG9377yaCiMjIyMgMS4gcnVsZXMKLS0tCiAgLSBtYXRjaCDvvJrnrKblkIjmjIflrprnmoTmnaHku7bvvIzmr5TlpoLmjIflrprnmoQgSVAg5Zyw5Z2A5ZKM56uv5Y+j44CCCiAgLSBkcm9wICDvvJrlvZPkuIDkuKrljIXliLDovr7ml7bvvIznroDljZXlnLDkuKLlvIPvvIzkuI3lgZrlhbblroPku7vkvZXlpITnkIbjgIIKICAtIGFjY2VwdO+8muWSjOS4ouW8g+ebuOWPje+8jOaOpeWPl+i/meS4quWMhe+8jOiuqei/meS4quWMhemAmui/h+OAggogIC0gcmVqZWN077ya5ZKM5Lii5byD55u45Ly877yM5L2G5a6D6L+Y5Lya5ZCR5Y+R6YCB6L+Z5Liq5YyF55qE5rqQ5Li75py65Y+R6YCB6ZSZ6K+v5raI5oGv44CC6L+Z5Liq6ZSZ6K+v5raI5oGv5Y+v5Lul5oyH5a6a77yM5Lmf5Y+v5Lul6Ieq5Yqo5Lqn55SfCiAgLSB0YXJnZXTvvJrmjIflrprnmoTliqjkvZzvvIzor7TmmI7lpoLkvZXlpITnkIbkuIDkuKrljIXvvIzmr5TlpoLvvJrkuKLlvIPvvIzmjqXlj5fvvIzmiJbmi5Lnu53jgIIKICAtIGp1bXDvvJrmjIflrprnmoTliqjkvZzvvIzor7TmmI7lpoLkvZXlpITnkIbkuIDkuKrljIXvvIzmr5TlpoLvvJrkuKLlvIPvvIzmjqXlj5fvvIzmiJbmi5Lnu53jgIIKICAtIHJ1bGXvvJrkuIDkuKrmiJblpJrkuKrljLnphY3lj4rlhbblr7nlupTnmoTnm67moIfjgIIKCiMjIyMgMi4gaXB0YWJsZXPlkoxuZXRmaWx0ZXLnmoTlhbPns7sKLS0tCmlwdGFibGVz5Y+q5pivTGludXjpmLLngavlopnnmoTnrqHnkIblt6XlhbfogIzlt7LvvIzkvY3kuo4vc2Jpbi9pcHRhYmxlcwrnnJ/mraPlrp7njrDpmLLngavlopnlip/og73nmoTmmK8gbmV0ZmlsdGVy77yM5a6D5pivTGludXjlhoXmoLjkuK3lrp7njrDljIXov4fmu6TnmoTlhoXpg6jnu5PmnoTjgIIKCiMjIyMgMy4gaXB0YWJsZXPnmoTop4TliJnooajlkozpk74KLS0tCi0g6KGo77yIdGFibGVz77yJ77yaCmlwdGFibGVz5YaF572u5LqGNOS4quihqO+8jOWNs2ZpbHRlcuihqOOAgW5hdOihqOOAgW1hbmdsZeihqOWSjHJhd+ihqOOAggrliIbliKvnlKjkuo7lrp7njrDljIXov4fmu6TvvIznvZHnu5zlnLDlnYDovazmjaLjgIHljIXph43mnoQo5L+u5pS5KeWSjOaVsOaNrui3n+i4quWkhOeQhuOAggoKLSDpk77vvIhjaGFpbnPvvInvvJoK5LiA5Liq5pyJ6aG65bqP55qEY2hlY2sgbGlzdO+8jOavj+S4gOadoemTvuS4reWPr+S7peacieS4gOadoeaIluaVsOadoeinhOWImeOAggrlpoLmnpzmu6HotrPvvIzns7vnu5/lsLHkvJrmoLnmja7or6XmnaHop4TliJnmiYDlrprkuYnnmoTmlrnms5XlpITnkIbor6XmlbDmja7ljIXvvJsK5ZCm5YiZaXB0YWJsZXPlsIbnu6fnu63mo4Dmn6XkuIvkuIDmnaHop4TliJnvvIzlpoLmnpzor6XmlbDmja7ljIXkuI3nrKblkIjpk77kuK3ku7vkuIDmnaHop4TliJnvvIxpcHRhYmxlc+WwseS8muagueaNruivpemTvumihOWFiOWumuS5ieeahOm7mOiupOetlueVpeadpeWkhOeQhuaVsOaNruWMheOAggoKLSDop4TliJnooajvvJoKICAgIDHvvIlmaWx0ZXLooajigJTigJTkuInkuKrpk77vvJpJTlBVVOOAgUZPUldBUkTjgIFPVVRQVVQK5L2c55So77ya6L+H5ruk5pWw5o2u5YyFIOWGheaguOaooeWdl++8mmlwdGFibGVzX2ZpbHRlci4KICAgIDLvvIlOYXTooajigJTigJTkuInkuKrpk77vvJpQUkVST1VUSU5H44CBUE9TVFJPVVRJTkfjgIFPVVRQVVQK5L2c55So77ya55So5LqO572R57uc5Zyw5Z2A6L2s5o2i77yISVDjgIHnq6/lj6PvvIkg5YaF5qC45qih5Z2X77yaaXB0YWJsZV9uYXQKICAgIDPvvIlNYW5nbGXooajigJTigJTkupTkuKrpk77vvJpQUkVST1VUSU5H44CBUE9TVFJPVVRJTkfjgIFJTlBVVOOAgU9VVFBVVOOAgUZPUldBUkQK5L2c55So77ya5L+u5pS55pWw5o2u5YyF55qE5pyN5Yqh57G75Z6L44CBVFRM44CB5bm25LiU5Y+v5Lul6YWN572u6Lev55Sx5a6e546wUU9T5YaF5qC45qih5Z2X77yaaXB0YWJsZV9tYW5nbGUo5Yir55yL6L+Z5Liq6KGo6L+Z5LmI6bq754Om77yM5ZKx5Lus6K6+572u562W55Wl5pe25Yeg5LmO6YO95LiN5Lya55So5Yiw5a6DKQogICA077yJUmF36KGo4oCU4oCU5Lik5Liq6ZO+77yaT1VUUFVU44CBUFJFUk9VVElORwrkvZznlKjvvJrlhrPlrprmlbDmja7ljIXmmK/lkKbooqvnirbmgIHot5/ouKrmnLrliLblpITnkIYg5YaF5qC45qih5Z2X77yaaXB0YWJsZV9yYXcKCi0g6KeE5YiZ6ZO+77yaCiAgIDHvvIlJTlBVVOKAlOKAlOi/m+adpeeahOaVsOaNruWMheW6lOeUqOatpOinhOWImemTvuS4reeahOetlueVpQogICAy77yJT1VUUFVU4oCU4oCU5aSW5Ye655qE5pWw5o2u5YyF5bqU55So5q2k6KeE5YiZ6ZO+5Lit55qE562W55WlCiAgIDPvvIlGT1JXQVJE4oCU4oCU6L2s5Y+R5pWw5o2u5YyF5pe25bqU55So5q2k6KeE5YiZ6ZO+5Lit55qE562W55WlCiAgIDTvvIlQUkVST1VUSU5H4oCU4oCU5a+55pWw5o2u5YyF5L2c6Lev55Sx6YCJ5oup5YmN5bqU55So5q2k6ZO+5Lit55qE6KeE5YiZCu+8iOiusOS9j++8geaJgOacieeahOaVsOaNruWMhei/m+adpeeahOaXtuS+r+mDveWFiOeUsei/meS4qumTvuWkhOeQhu+8iQogICA177yJUE9TVFJPVVRJTkfigJTigJTlr7nmlbDmja7ljIXkvZzot6/nlLHpgInmi6nlkI7lupTnlKjmraTpk77kuK3nmoTop4TliJkK77yI5omA5pyJ55qE5pWw5o2u5YyF5Ye65p2l55qE5pe25L6v6YO95YWI55Sx6L+Z5Liq6ZO+5aSE55CG77yJCi0tLQojIyMgY29tbWFuZApb5Y+C54WnXShodHRwOi8vdC56b3VrYW5rYW4uY29tL3NpeGxvb3AtcC1pcHRhYmxlcy1zYXZlLWhlbHAuaHRtbCkKW+WRveS7pOWPgueFp10oaHR0cHM6Ly96aHVhbmxhbi56aGlodS5jb20vcC8xNjA4NDA5MDYpCgoKaXB0YWJsZXMgLS1oZWxwIOS5n+iDveeci+WIsCzlhYjliJflh7rkuIDkupvluLjnlKjnmoQuCgogICAgLUEgLS1hcHBlbmQgCiAgICBBcHBlbmQgdG8gY2hhaW4KICAgIC1tIC0tbWF0Y2ggbWF0Y2gKICAgICAgICBleHRlbmRlZCBtYXRjaCAobWF5IGxvYWQgZXh0ZW5zaW9uKQogICAgLXMgLS1zb3VyY2UgYWRkcmVzc1svbWFza11bLi4uXQogICAgICAgIHNvdXJjZSBzcGVjaWZpY2F0aW9uCiAgICAtZCAtLWRlc3RpbmF0aW9uIC1kIGFkZHJlc3NbL21hc2tdWy4uLl0KICAgICAgICBkZXN0aW5hdGlvbiBzcGVjaWZpY2F0aW9uCiAgICAtaiAtLWp1bXAgLWogdGFyZ2V0IAogICAgICAgIHRhcmdldCBmb3IgcnVsZSAobWF5IGxvYWQgdGFyZ2V0IGV4dGVuc2lvbikKICAgIC1wIC0tcHJvdG9jb2wgLXAgcHJvdG8KICAgICAgICBwcm90b2NvbDogYnkgbnVtYmVyIG9yIG5hbWUsIGVnLiAndGNwJwogICAgLU4gLS1uZXcgLU4gY2hhaW4KICAgICAgICBDcmVhdGUgYSBuZXcgdXNlci1kZWZpbmVkIGNoYWluCiAgICAtdCAtLXRhYmxlIC10IHRhYmxlCQogICAgICAgIHRhYmxlIHRvIG1hbmlwdWxhdGUgKGRlZmF1bHQ6IGBmaWx0ZXInKQogICAgLWkgLS1pbi1pbnRlcmZhY2UgLWkgWyFdIGlucHV0IG5hbWVbK10KICAgICAgICBuZXR3b3JrIGludGVyZmFjZSBuYW1lIChbK10gZm9yIHdpbGRjYXJkKQogICAgLW8gLS1vdXQtaW50ZXJmYWNlIC1vIFshXSBvdXRwdXQgbmFtZVsrXQoJCQkJbmV0d29yayBpbnRlcmZhY2UgbmFtZSAoWytdIGZvciB3aWxkY2FyZCkKIyMjIOS4gOS6m21lbW8KLS0tClvmlrDmiYvmlZnlraZdKGh0dHBzOi8vd3d3LnpzeXRoaW5rLm5ldC9hcmNoaXZlcy8xMTk5KQoKMS4g6YCa5bi45oiR5Lus5Y+q5YWz57O7bmF06KGo5ZKMZmlsdGVy6KGoCmByYXcgLT4gbWFuZ2xlIC0+IG5hdCAtPiBmaWx0ZXJgIAoyLiDliJvlu7ogY2hhaW4g5pe25YCZ77yM5aaC5p6c5LiN5oyH5a6aLXQgdGFibGXvvIzpu5jorqTmmK9maWx0ZXLooagKMy4g77yBIOihqOekuiDlj5bpnZ4KYC1wICEgdGNwIOihqOekuuS4jeaYr3RjcOeahGAKNC4gaXB0YWJsZXMgLWgg5Lit55qEWyFd6KGo56S65pSv5oyBIOmdniDop4TliJkKYFshXSAtLXByb3RvY29sCS1wIHByb3RvCXByb3RvY29sOiBieSBudW1iZXIgb3IgbmFtZSwgZWcuIHRjcGAKNS4gLWkgLW8g5piv5Yy56YWN572R5Y2hCjYuIGlwdGFibGVzIC1tIGNvbW1lbnQg5qih5Z2XCmBpcHRhYmxlcyAtbSBjb21tZW50IC0tY29tbWVudCAieHh4ImAgCuWwseaYr+WvueivpWNoYWlu6L+b6KGM6Kej6YeK44CC5YW25LitY29tbWVudOaYr+aJqeWxleaooeWdl++8jOW4uOingeeahOaooeWdl+aciWFkZHJ0eXBlIOaooeWdl+S6huOAggpgaXB0YWJsZXMgLW0gYWRkcnR5cGUgLS1kc3QtdHlwZSBMT0NBTCAtaiBET0NLRVJgCmBpcHRhYmxlcyAtbSBhZGRydHlwZSAtLWhlbHAg5Y+v5Lul55yL5pu06K+m57uG6Kej6K+0YAphZGRydHlwZeihqOekuuWvueaKpeaWh+eahOWcsOWdgOexu+Wei+i/m+ihjOWMuemFje+8jC1kc3QtdHlwZSDooajnpLpkZXN0aW5hdGlvbgpMT0NBTDrooajnpLrlnLDlnYDmmK/mnKzlnLDlnLDlnYDvvIzmjIfmnKzlnLDkuIDliIflnLDlnYDlkKvvvJoxMjcuMC4wLjHlm57njq/lnLDlnYAKCjcuIC1qIEROQVQg5ZKMIC1qIFNOQVQKOC4g", + "subType": "00" + } + }, + "size": 0, + "order": 2, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "642066363b154137c10a99c9" + }, + "bid": "2023032623358600000000000026", + "owner": "3272499474", + "title": "iptables 规则和ACTION", + "btId": "2022050410146100000000000003", + "content": { + "$binary": { + "base64": "### 规则查询
---
`iptables -t filter -L`
`iptables -nvL INPUT`

    [root@node3 ~]# iptables -nvL INPUT
    # policy 表示默认规则
    Chain INPUT (policy ACCEPT 344K packets, 31M bytes)
     pkts bytes target     prot opt in     out     source               destination         
        0     0 in_test    tcp  --  *      *       0.0.0.0/0            0.0.0.0/0            tcp dpt:8000
    1741K  187M KUBE-FIREWALL  all  --  *      *       0.0.0.0/0            0.0.0.0/0

### 规则管理
---
`iptables -F INPUT`
    
    # 清空filter表的INPUT链
    iptables -F INPUT

    # 添加拒绝INPUT规则
    # -I 表示链首插入规则，-A 表示链尾添加规则
    # 来自49.233.4.79 的 丢弃
    iptables -t filter -I INPUT -s 49.233.4.79 -j DROP 
    # 所以就算添加了下面的ACCEPT规则，也是ping不同的，因为在链首已经被丢弃
    iptables -t filter -A INPUT -s 49.233.4.79 -j ACCEPT
    # 如果我再把这个规则添加到链首，就可以ping通了。
    iptables -t filter -I INPUT -s 49.233.4.79 -j ACCEPT 

    [root@node3 ~]# iptables -nvL INPUT
    Chain INPUT (policy ACCEPT 451 packets, 45257 bytes)
    pkts bytes target     prot opt in     out     source               destination         
    2   168 ACCEPT     all  --  *      *       49.233.4.79          0.0.0.0/0           
    5   420 DROP       all  --  *      *       49.233.4.79          0.0.0.0/0           
    0     0 ACCEPT     all  --  *      *       49.233.4.79          0.0.0.0/0    

### 删除规则
---
    
    # 指定编号删除 -D INPUT 3 ，删除INPUT 链中，编号为3的规则
    # 先查看规则编号 使用--line
    iptables -nvL INPUT --line
    iptables -t filter -D INPUT 3

    # 根据匹配条件删除
    iptables -t filter -D INPUT -s 49.233.4.79 -j ACCEPT

    # 整体删除
    iptables -t filter -F

### 修改规则
---
  
    # 使用-R 指定链，使用数字 来指定 具有相同数字编号的规则
    iptables -t filter -R INPUT 1 -s 49.233.4.79 -j REJECT

    # 可以看到 REJECT是拒绝行为
    [root@node1 tomcat]# ping 43.138.73.106
    PING 43.138.73.106 (43.138.73.106) 56(84) bytes of data.
    From 43.138.73.106 icmp_seq=1 Destination Port Unreachable
    From 43.138.73.106 icmp_seq=2 Destination Port Unreachable
### 保存规则
---
    
    service iptables save

### 匹配规则
---
1. 如果匹配不到任何规则，那么就匹配默认规则（policy）。

        # 小误区，关于！ 的用法理解，
        iptable -t filter -F
        # 不是 49.233.4.79 的都接受，但是并没有说是49.233.4.79的拒绝  
        # 只是说49.233.4.79的没有匹配到这个规则，因为INPUT 默认都是 ACCEPT
        # 所以，49.233.4.79的也会通过
        iptables -t filter -A INPUT 1 -s ！49.233.4.79 -j ACCEPT
        # -s -d 如果不指定，即0.0.0.0/0 即所有ip
        # 多个条件是 and 关系，必须都符合
2. 匹配条件：协议类型
    
        # 使用-p选项，指定需要匹配的报文的协议类型
        # 比如我们拒绝tcp协议
        iptables -t filter -F
        iptables -t filter -I INPUT -s 49.233.4.79 -p tcp -j REJECT
        # 这样我们ping 是可以ping通的，因为ping是icmp协议
        # 而curl 43.138.73.106 是被拒绝的，因为是http（tcp）协议
        # centos7中 支持以下协议
        # tcp, udp, udplite, icmp, icmpv6,esp, ah, sctp, mh
        # 不指定协议，即 -p all 任意匹配

3. 匹配条件：网卡接口
  
        # -i -o
        # -i 表示来自哪个网卡
        # PREROUTING 和 INPUT FORWARD 使用
        # -o 表示要去哪个网卡
        # POSTROUTING 和 OUTPUT FORWARD 使用
4. -m match 扩展匹配

        # 如果想要使用扩展匹配条件，则需要依赖一些扩展模块
        # 即扩展匹配，需要使用-m来指定模块
        iptables -A INPUT -s 49.233.4.79 -p tcp -m tcp --dport 80 -j REJECT
        [root@node3 ~]#     iptables -nvL INPUT --line
        Chain INPUT (policy ACCEPT 14 packets, 964 bytes)
        num   pkts bytes target     prot opt in     out     source               destination         
        1        2   120 REJECT     tcp  --  *      *       49.233.4.79          0.0.0.0/0            reject-with icmp-port-unreachable
        2        0     0 REJECT     tcp  --  *      *       49.233.4.79          0.0.0.0/0            tcp dpt:80 reject-with icmp-port-unreachable
        # 可以看出 上面是使用-m tcp 使用tcp扩展模块
        # 如果-p tcp 和 -m tcp 是一样的时候，-m tcp是可以省略的
        # --sport 表示源端口号
        # –dport 22:25 表示22，23，24，25 范围
        # ：22 和 80： 表示 0：22 80：65535
        # 多个离散端口使用 multiport 模块
        -m multiport –dports 22,36,80

5. -m iprange 扩展模块

        使用iprange扩展模块可以指定”一段连续的IP地址范围”，用于匹配报文的源地址或者目标地址
        # --src-range       --dst-range
        -m iprange --src-range 192.168.1.127-192.168.1.146

6. -m conntrack 扩展模块

        conntrack 状态跟踪
        conntrack共可以为连接标记五种状态：
        NEW，ESTABLISHED，RELATED，INVALID，UNTRACKED


### 自定义链
---

    自定义链并不能直接使用，而是需要被默认链引用才能够使
    # 自定义链IN-WEB
    iptables -F INPUT
    iptables -N IN-WEB
    # 可以看到，自定义链没有被任何默认的链引用，即无效状态。
    Chain IN-WEB (0 references)
     pkts bytes target     prot opt in     out     source               destination 
        
    删除 -X 自定义链，但是删除前必须要清空链上的规则
    iptables -F IN-WEB
    iptables -X IN-WEB

### ACTION
---
    我们知道-j target ，target既可以接ACTION，也可以接Chain
    我们已知的ACTION有 ACCEPT，DROP，REJECT

   `ACCPET`

    ACCEPT 将封包放行，进行完此处理动作后，将不再比对其它规则，直接跳往下一个规则炼。    
   `MARK`

    MARK 将封包标上某个代号，以便提供作为后续过滤的条件判断依据，进行完此处理动作后，将会继续比对其它规则
   `RETURN` 
    
    结束在目前规则炼中的过滤程序，返回主规则炼继续过滤.
    如果把自定义规则炼看成是一个子程序，那么这个动作，就相当于提早结束子程序并返回到主程序中。
   `SNAT` 

    改写封包来源 IP 为某特定 IP 或 IP 范围，可以指定 port 对应的范围，进行完此处理动作后
    将直接跳往下一个规则炼（mangle:postrouting）。范例如下：
    iptables -t nat -A POSTROUTING -p tcp -o eth0 -j SNAT --to-source 194.236.50.155-194.236.50.160:1024-32000
   `DNAT`

    DNAT 改写封包目的地 IP 为某特定 IP 或 IP 范围，可以指定 port 对应的范围，进行完此处理动作后，
    将会直接跳往下一个规则炼（filter:input 或 filter:forward）。范例如下： 
    iptables -t nat -A PREROUTING -p tcp -d 15.45.23.67 --dport 80 -j DNAT --to-destination 192.168.1.1-192.168.1.10:80-100
   `REJECT`

    拦阻该封包，并传送封包通知对方

   `DROP`

    丢弃封包不予处理，进行完此处理动作后，将不再比对其它规则，直接中断过滤程序

   `REDIRECT`
    
    ...
   `MASQUERADE`

    ...


   `NAT这个概念：`

    NAT是Network Address Translation的缩写，译为”网络地址转换”，NAT说白了就是修改报文的IP地址
    -j SNAT --to-source xxx.xxx.xxx.x
    -j DNAT --to-destination xxx.xx

### 关于链的顺序
---

- nat     表中的规则可以被哪些链使用：PREROUTING，OUTPUT，POSTROUTING（centos7中还有INPUT，centos6中没有）

- filter  表中的规则可以被哪些链使用：INPUT，FORWARD，OUTPUT 

      raw 和 mangle不去考虑的话
      表的顺序是 nat -> filter
      1. 当一个数据包进入网卡时，它首先进入PREROUTING链      
      nat -> PREROUTING
      
      2.1 如果数据包就是进入本机的
      nat -> INPUT
      filter -> INPUT
      nat -> OUTPUT
      filter -> OUTPUT

      2.2 如果数据包是需要转发的
      filter -> FORWARD

      3. 最后进入POSTROUTING
      nat -> POSTROUTING
    
1
2


", + "subType": "00" + } + }, + "size": 0, + "order": 1, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "6420681f3b154137c10a99ca" + }, + "bid": "2023032623438200000000000027", + "owner": "3272499474", + "title": "协议", + "btId": "2022050410146100000000000003", + "content": { + "$binary": { + "base64": "IyMg5Y2P6K6uCuS8oOi+k+WxglRDUCAtIArnvZHot6/lsYLljY/orq5JUCAtIOaKpeaWhwrmlbDmja7pk77ot6/lsYLljY/orq5NQUMgLSDluKcKLS0tCiMjIyBBUlDljY/orq4KLS0tCltBUlBdKGh0dHBzOi8vYmxvZy5jc2RuLm5ldC93ZWl4aW5fMzk3NjE2OTYvYXJ0aWNsZS9kZXRhaWxzLzExMDU3ODQ0NCkKQUREUkVTUyBSZXNvbHV0aW9uIHByb3RvY29sIOaYr+S4gOS4qumAmui/h+esrOS4ieWxgklQ5Zyw5Z2A77yM5om+5Yiw56ys5LqM5bGCTUFD55qE5Y2P6K6u44CCCk9TSeaooeWei+aKiue9kee7nOi/kOiQpeWIhuaIkOS4g+Wxgu+8jElQ5Zyw5Z2A5ZyoT1NJ5qih5Z6L55qE56ys5LiJ5bGC77yMTUFD5Zyw5Z2A5Zyo56ys5LqM5bGC77yM5b285q2k5LmL6Ze05LiN56uL5Y2z55u45aSE44CC5Zyo5qC55o2u5Lul5aSq572R5o6l5Y+j5o6o6YCBSVDmlbDmja7ml7bvvIzlv4XpobvlhYjlsIHoo4XlvaLlvI/nrKzkuInlsYLvvIgzMuS9jUlQ5Zyw5Z2A77yJ44CB5YaN5bCB6KOF56ys5LqM5bGC77yINDjkvY1NQUPlnLDlnYDvvInnmoTmiqXlpLTvvIzkvYblm6DkuLrmjqjpgIHml7blj6rkuobop6PmgLvkvZPnm67moIdJUOWcsOWdgO+8jOS4jea4healmuWFtk1BQ+WcsOWdgO+8jOWPiOS4jeWPr+S7pei3qOesrOS6jOOAgeS4ieWxgu+8jOWboOatpOW/hemhu+W6lOeUqOWcsOWdgOino+aekOWNj+S5ieOAggoK", + "subType": "00" + } + }, + "size": 0, + "order": 3, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "64258a0e3b154137c10a99cb" + }, + "bid": "2023033021097900000000000028", + "owner": "3272499474", + "title": "ssh 免密登录", + "btId": "00000000000004", + "content": { + "$binary": { + "base64": "IyMgc3NoCgojIyMgMS4gc3NoIGluc3RhbGwKYGBgYmFzaAphcHQtZ2V0IGluc3RhbGwgb3BlbnNzaC1zZXJ2ZXIgb3BlbnNzaC1jbGllbnQKYGBgCmBgYGJhc2gKc2VydmljZSBzc2ggc3RhcnQKYGBgCgojIyMgMi4gc3No5YWN5a+G55m75b2V55qE6K6+572u5Y2B5YiG566A5Y2VCgoKMeOAgWNkIH7lm57liLDkuLvnm67lvZXvvIzov5vlhaUuc3No5paH5Lu2CmBgYGJhc2gKY2Qgfi8uc3NoCmBgYAoy44CBc3NoLWtleWdlbiAtdCByc2Eg5ZCO77yM6L+e57ut5pWy5LiJ5qyh5Zue6L2m77yM55Sf5oiQ5Lik5Liq5paH5Lu2IGlkX3JzYeaYr+engemSpe+8jGlkX3JzYS5wdWLmmK/lhazpkqUKYGBgYmFzaApzc2gta2V5Z2VuIC10IHJzYQpgYGAKM+OAgeWwhuWFrOmSpeaLt+i0neWIsOebruagh+acuuWZqOS4igpgYGBiYXNoCnNzaC1jb3B5LWlkIG5vZGUxCmBgYAoK566A5Y2V5p2l6K+077yM5bCx5piv5ZyobWFzdGVy5py65Zmo55Sf5oiQ5a+G6ZKl5a+544CC5bCG5YWs6ZKl5YiG5Y+R57uZ5YW25LuW55qE5py65Zmo44CCCm5vZGUx77yMbm9kZTLvvIxub2RlM++8jOi/meWPquaYr+WNleWQkeeahOaDheWGteOAggrlpoLmnpzkupLnm7jlhY3lr4bnmbvlvZXnmoTor53vvIzlsLHpnIDopoHlgZpOKk7nmoTorr7nva4=", + "subType": "00" + } + }, + "size": 0, + "order": 0, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "64258a693b154137c10a99cc" + }, + "bid": "2023033021115000000000000029", + "owner": "3272499474", + "title": "Mongo Replica 集群搭建", + "btId": "2022050319356100000000000001", + "content": { + "$binary": { + "base64": "## Replica Set 集群搭建
本篇文章记录了基于mongodb-kubernetes-operator【Replica Set】模式集群搭建。
[1]()
[2](https://github.com/mongodb/mongodb-kubernetes-operator)
[3](https://github.com/mongodb/mongodb-kubernetes-operator/blob/master/docs/install-upgrade.md#install-the-operator-using-kubectl)

### 1. 事前准备

> kubernetes 版本： 1.23.9  
> mongodb 版本：6.0.2  
> nfs： 提前搭建好了kubernetes的nfs系统（具体搭建可以参照）。

### 2. github项目mongodb-kubernetes-operator

[项目地址](https://github.com/mongodb/mongodb-kubernetes-operator)

我们使用mongodb 官网推荐的 mongodb-kubernetes-operator 来进行集群安装。  
[document](https://github.com/mongodb/mongodb-kubernetes-operator/blob/master/docs/install-upgrade.md#install-the-operator-using-kubectl)

我们事先把 mongodb-kubernetes-operator 项目中我们要使用的yaml文件复制到我们的工作目录 mongo, 需要的文件夹如下：

    + mongo
      + config/crd/bases/
      + config/rbac/
      + config/manager/
      + config/samples/mongodb.com_v1_mongodbcommunity_cr.yaml
      + deploy/clusterwide/

    $ pwd
    /usr/local/kubernetes/mongo
    $ ls
    config deploy
    
### 3. 按照document依次进行安装
#### 3.1 创建 mongodb 使用的namespace

    kubectl create ns kube-mongo

#### 3.2 创建集群rbac 权限
  
    # 修改 deploy/clusterwide/cluster_role_binding.yaml 中namespace 为 3.1 中我我们创建的 [kube-mongo]
    kubectl apply -f deploy/clusterwide
    kubectl apply -k config/rbac --namespace kube-mongo

#### 3.3 创建 crd

    kubectl apply -f config/crd/bases/mongodbcommunity.mongodb.com_mongodbcommunity.yaml
    
#### 3.4 安装operator

    kubectl create -f config/manager/manager.yaml --namespace kube-mongo

#### 3.5 安装mongodb
修改 config/samples/mongodb.com_v1_mongodbcommunity_cr.yaml文件  
- 修改 MongoDBCommunity 资源
我们修改 metadata.name=violin-mongodb
我们修改 spec.version= "6.0.2"
我们修改 spec.users.name[0].passwordSecretRef.name= kube-mongo-pw
- 修改 Secret 资源
我们修改 metadata.name= kube-mongo-pw
我们修改 stringData.password= "任意随意写了吧"

然后进行安装

    kubectl apply -f config/samples/mongodb.com_v1_mongodbcommunity_cr.yaml --namespace kube-mongo

#### 3.6 重新创建pvc
由于我使用的是自定义的storageclass，pvc 处于 pending状态，我们删除掉pvc

    kubectl delete pvc data-volume-violin-mongodb-0 -n kube-mongo
    kubectl delete pvc logs-volume-violin-mongodb-0 -n kube-mongo

我们创建新的pvc定义文件：

    # pvc.yaml
    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: data-volume-violin-mongodb-0
      namespace: kube-mongo
    spec:
      accessModes:
      - ReadWriteOnce
      resources:
        requests:
          storage: 10Gi
      storageClassName: managed-nfs-storage
    ---
    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: data-volume-violin-mongodb-1
      namespace: kube-mongo
    spec:
      accessModes:
      - ReadWriteOnce
      resources:
        requests:
          storage: 10Gi
      storageClassName: managed-nfs-storage
    ---
    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: data-volume-violin-mongodb-2
      namespace: kube-mongo
    spec:
      accessModes:
      - ReadWriteOnce
      resources:
        requests:
          storage: 10Gi
      storageClassName: managed-nfs-storage
    ---
    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: logs-volume-violin-mongodb-0
      namespace: kube-mongo
    spec:
      accessModes:
      - ReadWriteOnce
      resources:
        requests:
          storage: 1Gi
      storageClassName: managed-nfs-storage
    ---
    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: logs-volume-violin-mongodb-1
      namespace: kube-mongo
    spec:
      accessModes:
      - ReadWriteOnce
      resources:
        requests:
          storage: 1Gi
      storageClassName: managed-nfs-storage
    ---
    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: logs-volume-violin-mongodb-2
      namespace: kube-mongo
    spec:
      accessModes:
      - ReadWriteOnce
      resources:
        requests:
          storage: 1Gi
      storageClassName: managed-nfs-storage

 我们 创建 pvc 

    kubectl apply -f pvc.yaml 
    # 查看pvc 是否已
    kubectl get pvc -n kube-mongo
    kube-mongo     data-volume-violin-mongodb-0   Bound    pvc-1ac1a5fd-389c-496d-a47c-7df11d5f5a34   10Gi       RWO            managed-nfs-storage   41m
    kube-mongo     data-volume-violin-mongodb-1   Bound    pvc-39008253-8702-4cc5-876a-0561850929bb   10Gi       RWO            managed-nfs-storage   61m
    kube-mongo     data-volume-violin-mongodb-2   Bound    pvc-a7e867d3-b499-486a-9b39-a42ac5a00b43   10Gi       RWO            managed-nfs-storage   61m
    kube-mongo     logs-volume-violin-mongodb-0   Bound    pvc-209ed46c-d558-4a09-8a2f-edfddbed610c   1Gi        RWO            managed-nfs-storage   41m
    kube-mongo     logs-volume-violin-mongodb-1   Bound    pvc-664b307f-ab95-4af3-8851-17a3ecd2b57c   1Gi        RWO            managed-nfs-storage   61m
    kube-mongo     logs-volume-violin-mongodb-2   Bound    pvc-a8f3a8d2-337d-4470-9ef4-5dbe18a4100a   1Gi        RWO            managed-nfs-storage   61m

### 4. 关于删除资源的问题。
我们创建operator 或者 statefuset 出错的时候，可以重新删除他们。

#### 4.1 删除 operator
    
    kubectl delete deployments.apps mongodb-kubernetes-operator -n kube-mongo

#### 4.1 删除 statefulset
    
    kubectl delete statefulsets.apps violin-mongodb -n kube-mongo

### 5. 关于 mongosh的使用

    kubectl get secret <connection-string-secret-name> -n <my-namespace> -o json | jq -r '.data | with_entries(.value |= @base64d)'

    kubectl get secret violin-mongodb-admin-my-user -n kube-mongo -o json | jq -r '.data | with_entries(.value |= @base64d)'

", + "subType": "00" + } + }, + "size": 0, + "order": 1, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "642e174f3b154137c10a99cd" + }, + "bid": "2023040608509800000000000030", + "owner": "3272499474", + "title": "kubernetes nfs ", + "btId": "2022050319356100000000000001", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "order": 0, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "642ee8073b154137c10a99ce" + }, + "bid": "2023040623407900000000000031", + "owner": "3272499474", + "title": "Mongo Replica 集群搭建-1", + "btId": "2022050319356100000000000001", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "order": 2, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "642fe1e43b154137c10a99cf" + }, + "bid": "2023040717276500000000000032", + "owner": "3272499474", + "title": "kubernetes ", + "btId": "2022050319356100000000000001", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "order": 0, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "6432acd0da833126fae88eaf" + }, + "bid": "2023040920175500000000000033", + "owner": "3272499474", + "title": "Docker", + "btId": "20230409", + "content": { + "$binary": { + "base64": "IyMgZG9ja2VyIOW4uOeUqCDlkb3ku6QKCiMjIyAxLiDliKDpmaQgTm9uZSDplZzlg48KYGBgCmRvY2tlciBpbWFnZXMgIHwgZ3JlcCBub25lIHwgYXdrICd7cHJpbnQgJDN9JyB8IHhhcmdzIGRvY2tlciBybWkKYGBgCg==", + "subType": "00" + } + }, + "size": 0, + "order": 0, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "6432ad87da833126fae88eb0" + }, + "bid": "2023040920200300000000000034", + "owner": "3272499474", + "title": "Git", + "btId": "20230409", + "content": { + "$binary": { + "base64": "6K+l5YaZ54K55LuA5LmI5LmILi4uCmh0dHBzOi8vYmlwcm9neS5ib3guY29tL3MvZjBkdTNydm85N3A0cnZhenpmcnE0MjM1ZGp4cWpzdmoKCgoK", + "subType": "00" + } + }, + "size": 0, + "order": 0, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "6432ad95da833126fae88eb1" + }, + "bid": "2023040920200900000000000035", + "owner": "3272499474", + "title": "Linux", + "btId": "20230409", + "content": { + "$binary": { + "base64": "IyMjIDEuIGxpbnV457O757uf54mI5pysCmBgYGJhc2gKdW5hbWUgLWEKY2F0IC9wcm9jL3ZlcnNpb24KYGBgCgojIyMgMi4gQ1BVCmBgYGJhc2gKZWNobyAid3VsaSBjcHUgZ2VzaHU6IiAKY2F0IC9wcm9jL2NwdWluZm8gfCBncmVwICJwaHlzaWNhbCBpZCIgfCB3YyAtbAplY2hvICJ3dWxpIGNwdSBnZXNodToiIApjYXQgL3Byb2MvY3B1aW5mbyB8IGdyZXAgInByb2Nlc3NvciIgfCB3YyAtbAplY2hvICJwZXIgY3B1IGhhcyBjb3JlczoiCmNhdCAvcHJvYy9jcHVpbmZvIHwgZ3JlcCAiY3B1IGNvcmVzIiB8IHVuaXEKYGBgCmBgYGJhc2gKY2F0IC9wcm9jL2NwdWluZm8gfCBncmVwICJuYW1lIiB8IGN1dCAtZjIgLWQ6IHwgdW5pcSAtYwpgYGAKCmBgYGJhc2gKbHNjcHUKYGBgCgpgYGBiYXNoCnRvcCAtYwpgYGAKCiMjIDMuIG1lbW9yeQpgYGBiYXNoCmNhdCAvcHJvYy9tZW1pbmZvCmZyZWUKYGBgCgojIyMgNC4g5pu05pS5aG9zdG5hbWUKCmBgYGJhc2gKdmkgL2V0Yy9ob3N0bmFtZQpgYGAKYGBgYmFzaAp2aSAvZXRjL2hvc3RzCmBgYApgYGBiYXNoCnJlYm9vdApgYGAKCiMjIDUuIG5ldHN0YXQKYGBgYmFzaApuZXRzdGF0IC1hbm8gfCBmaW5kc3RyIDUwMDAKdGFza2tpbGwgL2YgL3BpZCAxMDQxNTIKYGBgCgoKIyMgNi4gcHPmn6XnnIvov5vnqIsKLSDmn6XnnIvmraPlpITkuo5SdW5uaW5n55qE6L+b56iLCmBgYGJhc2gKcHMgLWVmCmBgYAotIOafpeeci+aJgOacieeahOi/m+eoiwpgYGBiYXNoCnBzIGF1eApgYGAKCiMjIDcuIG1vdW50Cgptb3VudOaYr0xpbnV45LiL55qE5LiA5Liq5ZG95Luk77yM5a6D5Y+v5Lul5bCG5YiG5Yy65oyC5o6l5YiwTGludXjnmoTkuIDkuKrmlofku7blpLnkuIvvvIzku47ogIzlsIbliIbljLrlkozor6Xnm67lvZXogZTns7votbfmnaXvvIzlm6DmraTmiJHku6zlj6ropoHorr/pl67ov5nkuKrmlofku7blpLnvvIzlsLHnm7jlvZPkuo7orr/pl67or6XliIbljLrkuobjgIIKCi0gc2hvdyBhbGwgdGhlIG1vdW50CmBgYGJhc2gKbW91bnQgLWwgCmBgYArlhbbkuK0gdG1wZnMg5piv5Li05pe25paH5Lu257O757uf77yM6ICMdG1wZnPmmK/kuIDkuKrmlofku7bns7vnu5/vvIzlubbkuI3mmK/lnZforr7lpIfvvIzlj6rmmK/lronoo4XlroPvvIzlsLHlj6/ku6Xkvb/nlKjkuobjgIJ0bXBmc+aYr+acgOWlveeahOWfuuS6jlJBTeeahOaWh+S7tuezu+e7nwoKCiMjIDguIGFsaWFzCiAgICAKLSBhbGlhcyBb5Yir5ZCNXT0n55yf5a6e5ZG95LukJwpgYGBiYXNoCmFsaWFzIGt1PSJrdWJlY3RsIgpgYGAKCgoKCgo=", + "subType": "00" + } + }, + "size": 0, + "order": 0, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "64335e5b6e07313606588754" + }, + "bid": "2023041008541300000000000036", + "owner": "3272499474", + "title": "kubeadm", + "btId": "2022050319356100000000000001", + "content": { + "$binary": { + "base64": "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", + "subType": "00" + } + }, + "size": 0, + "order": 0, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "643906d46e07313606588755" + }, + "bid": "2023041415557100000000000037", + "owner": "3272499474", + "title": "kubernetes containerd", + "btId": "2022050319356100000000000001", + "content": { + "$binary": { + "base64": "IyMgY29udGFpbmVyZAoKCgoKIyMgY3RyCgojIyBjcmljdGwKCiMjIG5lcmRjdGwKCiMjIA==", + "subType": "00" + } + }, + "size": 0, + "order": 0, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "64845adc6e07313606588756" + }, + "bid": "2023061019139700000000000038", + "owner": "3272499474", + "title": "新增加work节点", + "btId": "2022050319356100000000000001", + "content": { + "$binary": { + "base64": "IyMg", + "subType": "00" + } + }, + "size": 0, + "order": 0, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "653b63e8d2715f2cf34fa09b" + }, + "bid": "2023102715164400000000000039", + "owner": "3272499474", + "title": "订单库存", + "btId": "00000000000004", + "content": { + "$binary": { + "base64": "5LiALuiuouWNlQoKLSDllYblk4FNYXN0ZXLooagK5ZWG5ZOBSUQK5YiG57G7SUQK5ZWG5ZOB5ZCN56ewCgoKLSDorqLljZXooagK6K6i5Y2VSUQK5pS26LSn5Lq6CuaUtui0p+WcsOWdgArmgLvph5Hpop0K5a6e5pS26YeR6aKdCuiBlOezu+eUteivnQrorqLljZXnirbmgIEK5pel5pyfCuWkh+azqAoKLSDorqLljZXor6bnu4booagK6K6i5Y2VSUQgCuWVhuWTgUlECuaXpeacnwrmibnmrKEK54q25oCB77yaIOmAgOi0p+i/mOaYr+i0reS5sArljZXku7cK5pWw6YePCuaAu+mHkeminQrlpIfms6gKCi0tLQoK5LqMLuWcqOW6k+euoeeQhgotIOW6k+WtmOihqArllYblk4FJRArllYblk4HmlbDph48K5ZWG5ZOB5Lu35qC8Cui/m+i0p+aJueasoQrov5votKfml6XmnJ8KCi0g5YWl5bqTCuWFpeW6k0lECuWFpeW6k+WOn+WboO+8mui/m+i0pyDov5jmmK/lrqLmiLfpgIDotKcK5YWl5bqT5pe26Ze0CgotIOWHuuW6kwrlh7rlupNJRArlh7rlupPljp/lm6DvvJog6ZSA5ZSuIOi/mOaYryDov5Tlk4HljoLlrrYK5Ye65bqT5pe26Ze0Ci0tLQoK5LiJLuWuouaIt+euoeeQhgrlrqLmiLflkI3np7AK5omL5py6CgpodHRwczovL3RlYW1zLm1pY3Jvc29mdC5jb20vbC9tZWV0dXAtam9pbi8xOSUzYW1lZXRpbmdfWXpnM05XUmxPVE10TWpKbE9TMDBZV1l4TFRrME5XWXRNVEZtTnpjeE16SXhOV0l5JTQwdGhyZWFkLnYyLzA/Y29udGV4dD0lN2IlMjJUaWQlMjIlM2ElMjIzZDA1YWMyNy1jMGEyLTQyZjctYmQ4Ni0yNmVmN2RiNWIzODIlMjIlMmMlMjJPaWQlMjIlM2ElMjJkZjEwNDI3MC1hODYxLTQ4YWYtYjlkYy03YTA2MDAxMjhmMTAlMjIlN2QKCg==", + "subType": "00" + } + }, + "size": 0, + "order": 0, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "662fc249d2715f2cf34fa09c" + }, + "bid": "2024042923524000000000000040", + "owner": "3272499474", + "title": "kubelet", + "btId": "2022050319356100000000000001", + "content": { + "$binary": { + "base64": "6K+l5YaZ54K55LuA5LmI5LmILi4u", + "subType": "00" + } + }, + "size": 0, + "order": 0, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "6632fca0d2715f2cf34fa09d" + }, + "bid": "2024050210383100000000000041", + "owner": "3272499474", + "title": "2024-05-02", + "btId": "00000000000004", + "content": { + "$binary": { + "base64": "5L2c5qWt5a6a576p", + "subType": "00" + } + }, + "size": 0, + "order": 0, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "6732018fd2715f2cf34fa09f" + }, + "bid": "2024111121075900000000000042", + "owner": "3272499474", + "title": "腾讯云证书从申请到发布", + "btId": "2024111121076600000000000003", + "content": { + "$binary": { + "base64": "IyMjIOeUs+ivtwrnlaUKCiMjIyDop6PmnpAK55WlCgojIyMg5omL5Yqo5Y+R5biDCgogICAgLy8g5Yib5bu6azhzIHNlY3JldAogICAga3ViZWN0bCBjcmVhdGUgc2VjcmV0IHRscyBodHRwcy1jYS0ke3l5eXlNTWRkfSAtLWNlcnQ9dmlvbGluLWhvbWUuY25fYnVuZGxlLmNydCAtLWtleT12aW9saW4taG9tZS5jbi5rZXkgLW4gZGV2b3BzCiAgICAvLyDnvJbovpFpbmdyZXNzCiAgICBrdWJlY3RsIGVkaXQgaW5ncmVzcyB2aW9saW4taW5ncmVzcyAtbiBkZXZvcHMKICAgIC8vIOabv+aNouWQjeWtlwogICAg55Wl77yM5L+d5a2Y6YCA5Ye6Cg==", + "subType": "00" + } + }, + "size": 0, + "order": 0, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "673206a2d2715f2cf34fa0a0" + }, + "bid": "2024111121297600000000000043", + "owner": "3272499474", + "title": "腾讯云账号", + "btId": "2024111121076600000000000003", + "content": { + "$binary": { + "base64": "IyMjIOS6kei0puWPtwoxLiDntKLlhYsgICAgCiAgICAKICAgICAgICDotKblj7dJRO+8mklEMTAwMDMxOTEzMTYzCiAgICAgICAgcXHlj7fvvJogMjQ0Mzg1NDE0CiAgICAgICAg6LSm5Y+35pyJ5pWI5pe26Ze077yaIDIwMjMtMDYtMTEgfiAyMDI2LTA2LTExCjIuIOW8oOWljgoKCiAgICAgICAg6LSm5Y+3SUTvvJoxMDAwMzE4OTk5NjYKICAgICAgICDlvq7kv6HotKblj7fvvJogCiAgICAgICAg6LSm5Y+35pyJ5pWI5pe26Ze077yaIDIwMjMtMDYtMTEgfiAyMDI2LTA2LTExCg==", + "subType": "00" + } + }, + "size": 0, + "order": 0, + "_class": "cn.violin.wiki.entity.BlogInfo" +},{ + "_id": { + "$oid": "67321462d2715f2cf34fa0a1" + }, + "bid": "2024111122270400000000000044", + "owner": "3272499474", + "title": "gogs ci/cd", + "btId": "2024111121076600000000000003", + "content": { + "$binary": { + "base64": "IyMjIDEuIFNlcnZpY2UKLS0tCiAgICBhcGlWZXJzaW9uOiB2MQogICAga2luZDogU2VydmljZQogICAgbWV0YWRhdGE6CiAgICAgIGxhYmVsczoKICAgICAgICBhcHA6IGdvZ3MKICAgICAgbmFtZTogZ29ncwogICAgICBuYW1lc3BhY2U6IGRldm9wcwogICAgc3BlYzoKICAgICAgcG9ydHM6CiAgICAgICAgLSBuYW1lOiBnb2dzCiAgICAgICAgICBwb3J0OiAzMDAwCiAgICAgICAgICBwcm90b2NvbDogVENQCiAgICAgICAgICB0YXJnZXRQb3J0OiAzMDAwCiAgICAgIHNlbGVjdG9yOgogICAgICAgIGFwcDogZ29ncwogICAgICB0eXBlOiBOb2RlUG9ydAoKIyMjIDIuIERlcGxveW1lbnQKLS0tCiAgICBhcGlWZXJzaW9uOiBhcHBzL3YxCiAgICBraW5kOiBEZXBsb3ltZW50CiAgICBtZXRhZGF0YToKICAgICAgbGFiZWxzOgogICAgICAgIGFwcDogZ29ncwogICAgICBuYW1lOiBnb2dzCiAgICAgIG5hbWVzcGFjZTogZGV2b3BzCiAgICBzcGVjOgogICAgICByZXBsaWNhczogMQogICAgICBzZWxlY3RvcjoKICAgICAgICBtYXRjaExhYmVsczoKICAgICAgICAgIGFwcDogZ29ncwogICAgICB0ZW1wbGF0ZToKICAgICAgICBtZXRhZGF0YToKICAgICAgICAgIGNyZWF0aW9uVGltZXN0YW1wOiBudWxsCiAgICAgICAgICBsYWJlbHM6CiAgICAgICAgICAgIGFwcDogZ29ncwogICAgICAgIHNwZWM6CiAgICAgICAgICBjb250YWluZXJzOgogICAgICAgICAgICAtIGltYWdlOiBnb2dzL2dvZ3MKICAgICAgICAgICAgICBpbWFnZVB1bGxQb2xpY3k6IElmTm90UHJlc2VudAogICAgICAgICAgICAgIG5hbWU6IGdvZ3MKICAgICAgICAgICAgICB2b2x1bWVNb3VudHM6CiAgICAgICAgICAgICAgICAtIG1vdW50UGF0aDogL2RhdGEKICAgICAgICAgICAgICAgICAgbmFtZTogdm9sdgogICAgICAgICAgdm9sdW1lczoKICAgICAgICAgICAgLSBob3N0UGF0aDoKICAgICAgICAgICAgICAgIHBhdGg6IC9yb290L2s4cy9tb29uZmRkL2dvZ3MvZGF0YQogICAgICAgICAgICAgICAgdHlwZTogRGlyZWN0b3J5T3JDcmVhdGUKICAgICAgICAgICAgICBuYW1lOiB2b2x2CgojIyMgMy4gUFZDCiAgICBraW5kOiBQZXJzaXN0ZW50Vm9sdW1lQ2xhaW0KICAgIGFwaVZlcnNpb246IHYxCiAgICBtZXRhZGF0YToKICAgICAgbmFtZTogZ29ncy1zZXJ2ZXItZGF0YQogICAgICBuYW1lc3BhY2U6IGRldm9wcwogICAgICBhbm5vdGF0aW9uczoKICAgICAgICB2b2x1bWUuYmV0YS5rdWJlcm5ldGVzLmlvL3N0b3JhZ2UtY2xhc3M6ICJtYW5hZ2VkLW5mcy1zdG9yYWdlIgogICAgc3BlYzoKICAgICAgYWNjZXNzTW9kZXM6CiAgICAgICAgLSBSZWFkV3JpdGVNYW55CiAgICAgIHJlc291cmNlczoKICAgICAgICByZXF1ZXN0czoKICAgICAgICAgIHN0b3JhZ2U6IDFHaQoKCg==", + "subType": "00" + } + }, + "size": 0, + "order": 0, + "_class": "cn.violin.wiki.entity.BlogInfo" +}] \ No newline at end of file diff --git a/AI/mechine learning/t_blog_type.json b/AI/mechine learning/t_blog_type.json new file mode 100644 index 0000000..288878e --- /dev/null +++ b/AI/mechine learning/t_blog_type.json @@ -0,0 +1,151 @@ +[{ + "_id": { + "$oid": "626e92e3ff47411696bdc502" + }, + "btId": "00000000000003", + "btName": "深入理解Java虚拟机", + "owner": "3272499474", + "updateTime": "", + "_class": "com.g.estate.entity.BlogType", + "order": 0 +},{ + "_id": { + "$oid": "627009d357c0264f499c3112" + }, + "btId": "00000000000002", + "btName": "Java and Spring", + "owner": "3272499474", + "updateTime": "", + "_class": "com.g.estate.entity.BlogType", + "order": 1 +},{ + "_id": { + "$oid": "6270c35457c0264f499c3114" + }, + "btId": "00000000000004", + "btName": "服务器和系统", + "owner": "3272499474", + "updateTime": "", + "_class": "com.g.estate.entity.BlogType", + "order": 2 +},{ + "_id": { + "$oid": "62711385ce1c9f5320a2d06a" + }, + "btId": "2022050319356100000000000001", + "btName": "Kubernetes 最佳实践", + "owner": "3272499474", + "updateTime": "", + "_class": "com.g.estate.entity.BlogType", + "order": 4 +},{ + "_id": { + "$oid": "6271e199ce1c9f5320a2d06c" + }, + "btId": "2022050410146100000000000003", + "btName": "计算机网路", + "owner": "3272499474", + "updateTime": "", + "_class": "com.g.estate.entity.BlogType", + "order": 7 +},{ + "_id": { + "$oid": "6273350ace1c9f5320a2d06e" + }, + "btId": "2022050510233200000000000005", + "btName": "AWS", + "owner": "3272499474", + "updateTime": "", + "_class": "com.g.estate.entity.BlogType", + "order": 6 +},{ + "_id": { + "$oid": "6275315fce1c9f5320a2d07f" + }, + "btId": "2022050622313300000000000022", + "btName": "十万个为什么", + "owner": "3272499474", + "updateTime": "", + "_class": "com.g.estate.entity.BlogType", + "order": 3 +},{ + "_id": { + "$oid": "6282353f1425aa536ca456d2" + }, + "btId": "2022051619278900000000000002", + "btName": "深入刨析Kubernetes", + "owner": "3272499474", + "updateTime": "", + "_class": "com.g.estate.entity.BlogType", + "order": 5 +},{ + "_id": { + "$oid": "628ae75d1425aa536ca456da" + }, + "btId": "2022052309468900000000000004", + "btName": "Azure", + "owner": "3272499474", + "updateTime": "", + "_class": "com.g.estate.entity.BlogType", + "order": 8 +},{ + "_id": { + "$oid": "6282759a1425aa536ca456d4" + }, + "btId": "2022051700024800000000000003", + "btName": "quantitative trading", + "owner": "3272499474", + "updateTime": "", + "_class": "com.g.estate.entity.BlogType", + "order": 9 +},{ + "_id": { + "$oid": "6352618afe546b1de2f76d41" + }, + "btId": "2022102117088800000000000001", + "btName": "machine learning", + "updateTime": "", + "_class": "cn.violin.home.book.entity.BlogType", + "owner": "3272499474", + "order": 10 +},{ + "_id": { + "$oid": "635262bbfe546b1de2f76d44" + }, + "btId": "2022102117130200000000000002", + "btName": "probability and statistics", + "updateTime": "", + "_class": "cn.violin.home.book.entity.BlogType", + "owner": "3272499474", + "order": 11 +},{ + "_id": { + "$oid": "63f71a39f3eea8401859f543" + }, + "btId": "2023022315480800000000000001", + "btName": "Golang", + "owner": "3272499474", + "updateTime": "2023-02-23 15:48:16", + "order": 12, + "_class": "cn.violin.wiki.entity.BlogType" +},{ + "_id": { + "$oid": "6432acd0da833126fae88eae" + }, + "btId": "20230409", + "btName": "常用 Command", + "owner": "3272499474", + "updateTime": "2023-04-09 20:17:25", + "order": 13, + "_class": "cn.violin.wiki.entity.BlogType" +},{ + "_id": { + "$oid": "6732018fd2715f2cf34fa09e" + }, + "btId": "2024111121076600000000000003", + "btName": "violin-home", + "owner": "3272499474", + "updateTime": "2024-11-11 21:07:39", + "order": 14, + "_class": "cn.violin.wiki.entity.BlogType" +}] \ No newline at end of file diff --git a/AI/mechine learning/violin-home.md b/AI/mechine learning/violin-home.md new file mode 100644 index 0000000..44d5508 --- /dev/null +++ b/AI/mechine learning/violin-home.md @@ -0,0 +1,125 @@ +# violin-home + +> 来源：原 mongodb 集合 `t_blog` · 整理日期：2026-08-25 +> 分类 ID：`2024111121076600000000000003` · 排序：14 · 文章数：3 + +## 目录 + +1. [腾讯云证书从申请到发布](#腾讯云证书从申请到发布) +2. [腾讯云账号](#腾讯云账号) +3. [gogs ci/cd](#gogs-cicd) + +--- + +## 1. 腾讯云证书从申请到发布 + +bid: `2024111121075900000000000042` + +### 申请 +略 + +### 解析 +略 + +### 手动发布 + + // 创建k8s secret + kubectl create secret tls https-ca-${yyyyMMdd} --cert=violin-home.cn_bundle.crt --key=violin-home.cn.key -n devops + // 编辑ingress + kubectl edit ingress violin-ingress -n devops + // 替换名字 + 略，保存退出 + +--- + +## 2. 腾讯云账号 + +bid: `2024111121297600000000000043` + +### 云账号 +1. 索克 + + 账号ID：ID100031913163 + qq号： 244385414 + 账号有效时间： 2023-06-11 ~ 2026-06-11 +2. 张奎 + + + 账号ID：100031899966 + 微信账号： + 账号有效时间： 2023-06-11 ~ 2026-06-11 + +--- + +## 3. gogs ci/cd + +bid: `2024111122270400000000000044` + +### 1. Service +--- + apiVersion: v1 + kind: Service + metadata: + labels: + app: gogs + name: gogs + namespace: devops + spec: + ports: + - name: gogs + port: 3000 + protocol: TCP + targetPort: 3000 + selector: + app: gogs + type: NodePort + +### 2. Deployment +--- + apiVersion: apps/v1 + kind: Deployment + metadata: + labels: + app: gogs + name: gogs + namespace: devops + spec: + replicas: 1 + selector: + matchLabels: + app: gogs + template: + metadata: + creationTimestamp: null + labels: + app: gogs + spec: + containers: + - image: gogs/gogs + imagePullPolicy: IfNotPresent + name: gogs + volumeMounts: + - mountPath: /data + name: volv + volumes: + - hostPath: + path: /root/k8s/moonfdd/gogs/data + type: DirectoryOrCreate + name: volv + +### 3. PVC + kind: PersistentVolumeClaim + apiVersion: v1 + metadata: + name: gogs-server-data + namespace: devops + annotations: + volume.beta.kubernetes.io/storage-class: "managed-nfs-storage" + spec: + accessModes: + - ReadWriteMany + resources: + requests: + storage: 1Gi + +--- diff --git a/AI/mechine learning/十万个为什么.md b/AI/mechine learning/十万个为什么.md new file mode 100644 index 0000000..0f92ed9 --- /dev/null +++ b/AI/mechine learning/十万个为什么.md @@ -0,0 +1,183 @@ +# 十万个为什么 + +> 来源：原 mongodb 集合 `t_blog` · 整理日期：2026-08-25 +> 分类 ID：`2022050622313300000000000022` · 排序：3 · 文章数：4 + +## 目录 + +1. [java基础面试问题1](#java基础面试问题1) +2. [31.序列化](#31序列化) +3. [反射的原理是什么](#反射的原理是什么) +4. [为什么JDK动态代理只能代理接口](#为什么jdk动态代理只能代理接口) + +--- + +## 1. java基础面试问题1 + +bid: `2022050622313400000000000023` + +## java基础面试问题 + +### 1. JAVA中的几种基本数据类型是什么，各自占用多少字节。 +基本数据类型有8种： + +整数型 +byte 1个字节 +short 2 字节 +int 4字节 +long 8个字节 + +浮点型 +float 4字节 +double 8字节 + +布尔型 +boolean 4字节 + +字节型 +Char 两字节 + +### 2. String类能被继承吗，为什么。 +String类是被final修饰的。 + +不可以的 +被final修饰的类是不能被继承的， +final修饰的方法是不能被重写的 +被final修饰的变量是无法重新指向另一个对象的。 + +可以的 +但是被final的方法是可以重载的。 + +### 3. StringBuilder和Stringbuffer区别 +都是字符串的类，性能String最低，Stringbuffer较好，StringBuilder最快。 +安全性上StringBuilder是线程不安全的。 +Stringbuffer是线程安全的。 + +### 4. 用过哪些Map类，都有什么区别， +HashMap是线程安全的吗,并发下使用的Map是什么，他们 +内部原理分别是什么，比如存储方式，hashcode，扩容，默认容量等。 + +比较我比较常用的 +线程不安全的HashMap，TreeMap。 +线程安全的ConcurrentHashMap， + +### 5. ArrayList和LinkedList有什么区别 + +### 6. hashMap + + JDK1.8 开始， 数组 + 链表 或者 数组 + 红黑树 + HashMap 维护了 一个 Node[] 的数组，默认的初始数组大小是16 + 负载因子为0.75，当数组中超出容量的0.75倍时，进行容量x2扩容。 + +## 重要源码部分 + + + 默认的负载因子，为什么是0.75？ + static final float DEFAULT_LOAD_FACTOR = 0.75f; + 默认的初始容量为16 + 1 -》 10000 —-》 16 + static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; + 最大容量为2的30次方 + static final int MAXIMUM_CAPACITY = 1 << 30; + 链表到红黑树转化的阈值 + static final int TREEIFY_THRESHOLD = 8; + 红黑树到链表转化的阈值 + static final int UNTREEIFY_THRESHOLD = 6; + 转树所必要的最小容量 + static final int MIN_TREEIFY_CAPACITY = 64; + public HashMap() { + this.loadFactor = DEFAULT_LOAD_FACTOR; + } + + 为什么是 异或 ？ 保持更好的散列性 + 右移 16位，高位补0，为什么 + static final int hash(Object key) { + int h; + return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); + } + + 这个loadFactor 会在 resize()方法中被调用 + resize() 也是node 节点初始化的 + +## 为什么是 异或 + ^ 表示 异或 运算符 - 》 相同为0 不相同为1 + 异或 可以保持更好的散列性。 + 与 运算 1/4 的是1 ，3/4 的是0，所以得到的数更小 + 或 运算 1/4 的是0 ，3/4 的是1，所以得到的数更大 + 异或 运算 2/4 的是1 ，2/4 的是0，所以得到的数更有散列性 + +## HashMap源码中在计算hash值的时候为什么要右移16位 + + (h = key.hashCode()) ^ (h >>> 16) + h & (length-1) 与运算 + + +## 为什么 负载因子 是 0.75 + +## mod 取模运算符 + + 在java 中 + 取 商 运算符 / + 取 余 运算符 % + + 计算整数商 c = a/b + 计算模 r = a - c*b + + x mod 2^n = x & (2^n - 1) + + 还是 以 10 / 8 为类 + x -》 1010 + 2^n 0111 + & 运算 0010 + ----------- + 2 + 从二进制角度来说，x （1010）向右移动3位，得到商（1） + 除掉的部分010 则是余数，即2 + +--- + +## 2. 31.序列化 + +bid: `2022050822283700000000000002` + +### 序列化 +--- +什么是序列化，怎么序列化，为什么序列化，反序列化会遇到什么问题，如何解决。 + +du + +--- + +## 3. 反射的原理是什么 + +bid: `2022050900177700000000000003` + +反射的原理，反射创建类实例的三种方式是什么 + +Jvm加载类（包括接口，注解，枚举，接口）信息时，会将该信息以类对象（包名.类名）的形式存储于方法区。 + +Java反射是指，在Jvm运行时，对于一个类，都能通过反射获取，这个类的属性，方法，构造器等，对于一个对象，通过反射可以调用他的全部属性和方法，这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 + +Java反射作为动态编译而存在，极大的提高了Java语言的灵活性。 + +Java反射有三种方式获取类实例（不是对象实例）： +1.Class.forName(),通过指定包名类名的方式在方法区去需要找该类。 +2.XXX.class， 通过类名.class,局限性是非动态。 +3.实例对象.getClass()。 + +第一种类加载方式，是加载外部类的最常用方式。 +第三种方式，是已知对象情况下的，获取该类的最好方式 + +--- + +## 4. 为什么JDK动态代理只能代理接口 + +bid: `2022122811384800000000000013` + +为什么JDK动态代理只能代理接口，不能直接代理类？CGlib为什么可以代理类？ + +动态代理生成的Proxy\$0类是继承了Proxy类并且implements代理接口，但由于java是不能多继承的，所以动态代理不能代理类。 + +cglib实现动态代理的逻辑是使用子类继承代理类，就没有单继承的限制了. + +--- diff --git a/AI/mechine learning/常用 Command.md b/AI/mechine learning/常用 Command.md new file mode 100644 index 0000000..d0c3b07 --- /dev/null +++ b/AI/mechine learning/常用 Command.md @@ -0,0 +1,120 @@ +# 常用 Command + +> 来源：原 mongodb 集合 `t_blog` · 整理日期：2026-08-25 +> 分类 ID：`20230409` · 排序：13 · 文章数：3 + +## 目录 + +1. [Docker](#docker) +2. [Git](#git) +3. [Linux](#linux) + +--- + +## 1. Docker + +bid: `2023040920175500000000000033` + +## docker 常用 命令 + +### 1. 删除 None 镜像 +``` +docker images | grep none | awk '{print $3}' | xargs docker rmi +``` + +--- + +## 2. Git + +bid: `2023040920200300000000000034` + +该写点什么么... +https://biprogy.box.com/s/f0du3rvo97p4rvazzfrq4235djxqjsvj + +--- + +## 3. Linux + +bid: `2023040920200900000000000035` + +### 1. linux系统版本 +```bash +uname -a +cat /proc/version +``` + +### 2. CPU +```bash +echo "wuli cpu geshu:" +cat /proc/cpuinfo | grep "physical id" | wc -l +echo "wuli cpu geshu:" +cat /proc/cpuinfo | grep "processor" | wc -l +echo "per cpu has cores:" +cat /proc/cpuinfo | grep "cpu cores" | uniq +``` +```bash +cat /proc/cpuinfo | grep "name" | cut -f2 -d: | uniq -c +``` + +```bash +lscpu +``` + +```bash +top -c +``` + +## 3. memory +```bash +cat /proc/meminfo +free +``` + +### 4. 更改hostname + +```bash +vi /etc/hostname +``` +```bash +vi /etc/hosts +``` +```bash +reboot +``` + +## 5. netstat +```bash +netstat -ano | findstr 5000 +taskkill /f /pid 104152 +``` + + +## 6. ps查看进程 +- 查看正处于Running的进程 +```bash +ps -ef +``` +- 查看所有的进程 +```bash +ps aux +``` + +## 7. mount + +mount是Linux下的一个命令，它可以将分区挂接到Linux的一个文件夹下，从而将分区和该目录联系起来，因此我们只要访问这个文件夹，就相当于访问该分区了。 + +- show all the mount +```bash +mount -l +``` +其中 tmpfs 是临时文件系统，而tmpfs是一个文件系统，并不是块设备，只是安装它，就可以使用了。tmpfs是最好的基于RAM的文件系统 + + +## 8. alias + +- alias [别名]='真实命令' +```bash +alias ku="kubectl" +``` + +--- diff --git a/AI/mechine learning/服务器和系统.md b/AI/mechine learning/服务器和系统.md new file mode 100644 index 0000000..d85a6da --- /dev/null +++ b/AI/mechine learning/服务器和系统.md @@ -0,0 +1,214 @@ +# 服务器和系统 + +> 来源：原 mongodb 集合 `t_blog` · 整理日期：2026-08-25 +> 分类 ID：`00000000000004` · 排序：2 · 文章数：7 + +## 目录 + +1. [Windows](#windows) +2. [关于Oauth的第三方授权登录](#关于oauth的第三方授权登录) +3. [网关（gateway）](#网关gateway) +4. [自己紹介](#自己紹介) +5. [ssh 免密登录](#ssh-免密登录) +6. [订单库存](#订单库存) +7. [2024-05-02](#2024-05-02) + +--- + +## 1. Windows + +bid: `2022051820523400000000000007` + +我们通过powershell安装时，经常提示 + +更改 Windows PowerShell 执行策略的用户首选项。 +Set-ExecutionPolicy +[Doc](https://docs.microsoft.com/zh-CN/previous-versions//dd347628(v=technet.10)?redirectedfrom=MSDN) + +Enable-WindowsOptionalFeature +[Doc](https://docs.microsoft.com/en-us/powershell/module/dism/enable-windowsoptionalfeature?view=windowsserver2022-ps) + + PS C:\WINDOWS\system32> Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Hyper-V-Tools-All + Enable-WindowsOptionalFeature : 功能名称 Microsoft-Hyper-V-Tools-All 未知。 + 所在位置 行:1 字符: 1 + + Enable-WindowsOptionalFeature -Online -FeatureName Microsoft-Hyper-V- ... + + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + CategoryInfo : NotSpecified: (:) [Enable-WindowsOptionalFeature + ], COMException + + FullyQualifiedErrorId : Microsoft.Dism.Commands.EnableWindowsOptionalFea + tureCommand + +--- + +## 2. 关于Oauth的第三方授权登录 + +bid: `2022102117264100000000000010` + +## 关于vilin-home的 安全认证 +--- +采用third part（第三方）认证 + token，暂时只支持百度云认证。 + +采用token 是防止 设备丢失等情况发生时，可以将用户暂时剔除租户体系，保证数据安全。是作为jwt认证的一种补充手段。 + +基本的认证flow如下： + +> 用户 -> 登录 violin-home 网站 + +> token check -> 没有token的话，进入wolcome 页面，进入登录诱导页面，有token则进入home页面 + +> 点击 百度云登录 跳转到 百度扫码 页面 + +> 扫码成功，返回 回调code的连接，同时使用code 访问 violin-book 进入token获取 + +> violin-book 获取到code后 向 百度云 进行认证，获取 token，同时进行租户check，没有租户情报的认证用户，返回sorrypage，有租户情报的认证用户，跟新认证token到redis，并且重定向到 violin-home-manage 连接 + +> 解析 violin-home-manage 连接，获取token，通过token ，向violin-book获取租户基本信息，然后 跳转到home页面 + +> 至此 认证 完了 + +--- + +## 3. 网关（gateway） + +bid: `2022121609222900000000000008` + +https://biprogy.box.com/s/e2k26k78uhd2x4yo4skjfghp0y7ipc2w + +https://app.boxcn.net/folder + +--- + +## 4. 自己紹介 + +bid: `2023021420423600000000000018` + +本日は貴重な時間をいただきありがとうございます。 + +カンショウイと申します。今年35歳です。 + +卒業した大学は中国の東北大学ですが、大学院生の出身大学はつくば大学、専門はシステム情報工学です。 + +卒業後、1年ぶりの土木系の仕事と一年ぶりの金融知識学習をしました。2017年からITに転職、それから創科技術会社、日本ハイロン株式会社、IBM株式会社の三社で働きました。 + +経験したプロジェクトは10個以上で、設計、開発、テスト、POC検証などのいくつかのフェーズも参加しました。 + +得意な開発言語はJava、Js、Go、kubernetesです。 + +IBMに入社後、フルスタックエンジニア、コンサルタントとアーキテクチャとして活躍しております。 + +去年はクラウドネイティブ　CKA　と　Azure Iotの資格を取りました。 + +この経験をぜひ御社でも生かしていきたいと考えております。 + +どうぞよろしくお願いいたします。 + +https://teams.microsoft.com/l/meetup-join/19%3ameeting_NjRlMmEwN2QtNTU1My00M2Q3LWEyNDEtODAyODE5OWFkODAy%40thread.v2/0?context=%7b%22Tid%22%3a%22b2c6da00-de63-4f6a-90ed-17e48a1f64a2%22%2c%22Oid%22%3a%2252e6675f-d902-4939-b53f-6b69aabfdf35%22%7d + +--- + +## 5. ssh 免密登录 + +bid: `2023033021097900000000000028` + +## ssh + +### 1. ssh install +```bash +apt-get install openssh-server openssh-client +``` +```bash +service ssh start +``` + +### 2. ssh免密登录的设置十分简单 + + +1、cd ~回到主目录，进入.ssh文件 +```bash +cd ~/.ssh +``` +2、ssh-keygen -t rsa 后，连续敲三次回车，生成两个文件 id_rsa是私钥，id_rsa.pub是公钥 +```bash +ssh-keygen -t rsa +``` +3、将公钥拷贝到目标机器上 +```bash +ssh-copy-id node1 +``` + +简单来说，就是在master机器生成密钥对。将公钥分发给其他的机器。 +node1，node2，node3，这只是单向的情况。 +如果互相免密登录的话，就需要做N*N的设置 + +--- + +## 6. 订单库存 + +bid: `2023102715164400000000000039` + +一.订单 + +- 商品Master表 +商品ID +分类ID +商品名称 + + +- 订单表 +订单ID +收货人 +收货地址 +总金额 +实收金额 +联系电话 +订单状态 +日期 +备注 + +- 订单详细表 +订单ID +商品ID +日期 +批次 +状态： 退货还是购买 +单价 +数量 +总金额 +备注 + +--- + +二.在库管理 +- 库存表 +商品ID +商品数量 +商品价格 +进货批次 +进货日期 + +- 入库 +入库ID +入库原因：进货 还是客户退货 +入库时间 + +- 出库 +出库ID +出库原因： 销售 还是 返品厂家 +出库时间 +--- + +三.客户管理 +客户名称 +手机 + +https://teams.microsoft.com/l/meetup-join/19%3ameeting_Yzg3NWRlOTMtMjJlOS00YWYxLTk0NWYtMTFmNzcxMzIxNWIy%40thread.v2/0?context=%7b%22Tid%22%3a%223d05ac27-c0a2-42f7-bd86-26ef7db5b382%22%2c%22Oid%22%3a%22df104270-a861-48af-b9dc-7a0600128f10%22%7d + +--- + +## 7. 2024-05-02 + +bid: `2024050210383100000000000041` + +作業定義 + +--- diff --git a/AI/mechine learning/深入刨析Kubernetes.md b/AI/mechine learning/深入刨析Kubernetes.md new file mode 100644 index 0000000..30c674d --- /dev/null +++ b/AI/mechine learning/深入刨析Kubernetes.md @@ -0,0 +1,2128 @@ +# 深入刨析Kubernetes + +> 来源：原 mongodb 集合 `t_blog` · 整理日期：2026-08-25 +> 分类 ID：`2022051619278900000000000002` · 排序：5 · 文章数：14 + +## 目录 + +1. [第2章 Docker](#第2章-docker) +2. [第3章 设计与架构](#第3章-设计与架构) +3. [kubernetes etcd安装](#kubernetes-etcd安装) +4. [第4章 kubeadm](#第4章-kubeadm) +5. [第5章 编排原理](#第5章-编排原理) +6. [第7章 网络原理](#第7章-网络原理) +7. [第6章 存储原理](#第6章-存储原理) +8. [第8章 调度与资源管理](#第8章-调度与资源管理) +9. [第10章 资源](#第10章-资源) +10. [第11章 权限控制](#第11章-权限控制) +11. [基于虚拟网卡共有网络k8s集群搭建](#基于虚拟网卡共有网络k8s集群搭建) +12. [kubernetes 二进制安装master](#kubernetes-二进制安装master) +13. [kubernetes Calico 配置](#kubernetes-calico-配置) +14. [kubernetes 二进制安装worker](#kubernetes-二进制安装worker) + +--- + +## 1. 第2章 Docker + +bid: `2022051619278900000000000003` + +## kubernetes 第2章 Docker +### docker network +--- +[参考１](https://baijiahao.baidu.com/s?id=1730776907492640810&wfr=spider&for=pc) +[参照２](https://blog.csdn.net/gui951753/article/details/79210535) + + # show network command: bridge, host, none + docker network ls + # bridge + # host + # none + +### docker 项目最核心的原理是，为带创建的用户进程 +### 重新认识linux容器 +--- +1.Linux Namespace 的隔离能力 +2.Linux Cgroups的限制能力 +3.基于rootfs的文件系统 +其中用到了chroot 和 pivot_root 两个系统调用切换进程目录的能力 +docker 在镜像的设计中引入了layer的概念 +docker镜像使用的rootfs往往由多个layer组成。 + 这些layer 分： +- ro+wh layer +- rw layer +- init layer +- init层是docker项目单独生成的内部层，专门存放/etc/hosts,/etc/resolv.conf等信息。用户 commit时 init层并不会提交。提交的时rw层。 + +### Dockerfile +--- +[doc](https://docs.docker.com/engine/reference/builder/) + + # Comment + INSTRUCTION arguments + + FROM python:2.7-slim + + WORKDIR /app + + ADD . /app + + RUN pip install --trusted-host pypi.python.org -r requirements.txt + + EXPOSE 80 + + ENV NAME World + + CMD ["python", "app.py"] + + # dockerfile默认提供了一个隐式的ENTRYPOINT INSTRUCTION + 即 /bin/sh -c + 所以Docker容器的启动进程为ENTRYPOINT， 而不是CMD + 而CMD命令为Dockerfile指定python app.py 为该容器进程 + CMD的内容就是ENTRYPOINT 的参数 + 实际上在容器中运行的进程为 /bin/sh -c "python app.py" + +### Linux Namespace 隔离机制 +--- +Linux Namespace虽然看不见摸不到，但是一个进程的Namespace信息在宿主机上是确实存在的，并且以文件的形式存在。 + + $ docker inspect --format '{{ .State.pid }}' 4ddf4542324 + 25686 + 此时，可以查看宿主机文件 + $ls -l /proc/25686/ns + 可以看出一个进程是有多个Namespace的，存放于该目录下。 + 这就意味着，一个进程可以选择加入某个Namespace中，这就是docker exec 原理 + +### docker Volume +在chroot之前，宿主机的文件目录对容器进程是可见的，我们只需要在rootfs准备好后，在执行chroot之前，把Volume指定的宿主机目录挂载到指定容器目录即可。 +Volume里信息不会被docker commit提交。 + +--- + +## 2. 第3章 设计与架构 + +bid: `2022051809471000000000000005` + +## kubernetes 第3章 设计与架构 +### Kubernetes 设计与架构 +--- +容器实际上是由，Linux Namespace，Linux Cgroup，rootfs 这三种技术构建出来的。 +不难看出一个运行中linux的容器其实可以被一分为二的： +1.挂载到/var/lib/docker/aufs/mnt上的rootfs，这一部分被称为容器镜像，是容器的静态视图。 +2.一个由Namespace+Cgroups构成的隔离环境，这一部分被称为容器运行时，是容器的动态视图。 +容器编排项目：compose+Swarm和Kubarnetes容器编排工具。 +### Kubernetes的核心能力与项目定位 +--- +Kubernetes 的本质是平台的平台，即一个用来帮助用户构建上层平台的基础平台。 +Pod是Kubernetes 中最基础的单元 +声明式API是kubernetes最核心的设计理念，通过 + +### apiserver + +### etcd + +### cri + +### kubectl + +### kubelet + +### proxy + +### + +--- + +## 3. kubernetes etcd安装 + +bid: `2022053111285300000000000018` + +### 删除kubeadm 残留信息 +--- + + yum remove -y kubelet kubeadm kubectl + + rm -rf /etc/kubernetes/ + rm -rf /etc/systemd/system/kubelet.service.d + rm -rf /etc/systemd/system/kubelet.service + rm -rf /usr/bin/kube* + rm -rf /etc/cni + rm -rf /opt/cni + rm -rf /var/lib/etcd + rm -rf /var/etcd + +### etcd 集群安装 +--- + +**1.1** 服务器规划 + + etcd-1 + etcd-2 + etcd-3 + +**1.2** 资源准备 + + wget https://github.com/kubernetes/kubernetes/archive/refs/tags/v1.23.8.tar.gz + + 从gethub源码中的go.mod可以看出，etcd的版本依赖是v3.5.0 + 然后我去下载etcd-v3.5.0 + wget https://github.com/etcd-io/etcd/releases/download/v3.5.0/etcd-v3.5.0-linux-amd64.tar.gz + +**1.3** cfssl证书生成工具准备 +cfssl是一个开源的证书管理工具，使用json文件生成证书，相比openssl更方便使用。 +找任意一台服务器操作，这里用Master1节点。 + + #创建目录存放cfssl工具 + mkdir /software-cfssl + + #下载相关工具 + cd /software-cfssl + wget -q --timestamping https://storage.googleapis.com/kubernetes-the-hard-way/cfssl/1.4.1/linux/cfssl https://storage.googleapis.com/kubernetes-the-hard-way/cfssl/1.4.1/linux/cfssljson + + cd /software-cfssl/ + chmod +x * + mv cfssl cfssljson /usr/local/bin + +**1.4** 自签证书颁发机构(CA) + + # 创建工作目录 + mkdir -p ~/TLS/{etcd,k8s} + cd ~/TLS/etcd/ + + # 生成自签CA配置 +```bash +cat > ca-config.json << EOF +{ + "signing": { + "default": { + "expiry": "87600h" + }, + "profiles": { + "www": { + "expiry": "87600h", + "usages": [ + "signing", + "key encipherment", + "server auth", + "client auth" + ] + } + } + } +} +EOF +``` +```bash +cat > ca-csr.json << EOF +{ + "CN": "etcd CA", + "key": { + "algo": "rsa", + "size": 2048 + }, + "names": [ + { + "C": "CN", + "L": "ShangHai", + "ST": "ShangHai" + } + ] +} +EOF +``` +- 生成自签CA证书 +```bash +cfssl gencert -initca ca-csr.json | cfssljson -bare ca - +``` +- ca的有效证书查看 +```bash +openssl x509 -in ca.pem -noout -text +``` + +**1.5** 签发etcd https证书 + + # 使用自签CA + cat > server-csr.json << EOF + { + "CN": "etcd", + "hosts": [ + "49.233.4.79", + "43.138.55.43", + "43.138.73.106", + "10.0.16.3", + "10.0.8.13", + "127.0.0.1" + ], + "key": { + "algo": "rsa", + "size": 2048 + }, + "names": [ + { + "C": "CN", + "L": "ShangHai", + "ST": "ShangHai" + } + ] + } + EOF +- 生成证书 +```bash +cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=www server-csr.json | cfssljson -bare server +``` + +- 查看有效期 +```bash + openssl x509 -in server.pem -noout -text +`` + +**1.5** 部署etcd集群 + + mkdir /usr/local/etcd-v3.5.0/{bin,cfg,ssl} -p + tar -xf etcd-v3.4.9-linux-amd64.tar.gz + mv etcd-v3.4.9-linux-amd64/{etcd,etcdctl} /usr/local/etcd-v3.5.0/bin/ +--- + # 创建etcd配置文件 + cat > /usr/local/etcd-v3.5.0/conf/etcd.conf << EOF + #[Member] + ETCD_NAME="etcd-1" # 需要修改 + ETCD_DATA_DIR="/var/lib/etcd/default.etcd" + ETCD_LISTEN_PEER_URLS="https://49.233.4.79:2380" + ETCD_LISTEN_CLIENT_URLS="https://49.233.4.79:2379" + + #[Clustering] + ETCD_INITIAL_ADVERTISE_PEER_URLS="https://49.233.4.79:2380" + ETCD_ADVERTISE_CLIENT_URLS="https://49.233.4.79:2379" + ETCD_INITIAL_CLUSTER="etcd-1=https://49.233.4.79:2380,etcd-2=https://43.138.55.43:2380,etcd-3=https://138.73.106:2380" + ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster" + ETCD_INITIAL_CLUSTER_STATE="new"　 + # etc-1 为new，etcd-2/2为existing,网上很多文章都是直接copy不改，是不好使的 + EOF +--- + # systemd管理etcd + cat > /usr/lib/systemd/system/etcd.service << EOF + [Unit] + Description=Etcd Server + After=network.target + After=network-online.target + Wants=network-online.target + + [Service] + Type=notify + EnvironmentFile=/usr/local/etcd-v3.5.0/conf/etcd.conf + User=root # 此处必须要指定用户，要不启动会报错 + ExecStart=/usr/local/etcd-v3.5.0/bin/etcd \ + --cert-file=/usr/local/etcd-v3.5.0/ssl/server.pem \ + --key-file=/usr/local/etcd-v3.5.0/ssl/server-key.pem \ + --peer-cert-file=/usr/local/etcd-v3.5.0/ssl/server.pem \ + --peer-key-file=/usr/local/etcd-v3.5.0/ssl/server-key.pem \ + --trusted-ca-file=/usr/local/etcd-v3.5.0/ssl/ca.pem \ + --peer-trusted-ca-file=/usr/local/etcd-v3.5.0/ssl/ca.pem \ + --logger=zap + Restart=on-failure + LimitNOFILE=65536 + + [Install] + WantedBy=multi-user.target + EOF +--- + 将master1节点所有生成的文件拷贝到节点2和节点3 + xsync etcd-v3.5.0 +--- + 修改节点2，节点3 ,etcd.conf配置文件中的节点名称和当前服务器IP: +--- + 启动etcd并设置开机自启 +--- + 检查etcd集群状态 +--- + etcd问题排查(日志) + less /var/log/message + journalctl -u etcd + journalctl -xe + + + etcd 默认数据目录 + /var/lib/etcd/ + # 只有第一次启动时候，发生"msg":"request cluster ID mismatch" + rm -rf /usr/local/etcd-v3.5.0/data + + systemctl stop etcd + systemctl start etcd + + etcd 启动 + etcd --config-file /usr/local/etcd-v3.5.0/conf/etcd.conf.yml + + etcd 后台启动 + nohup etcd --config-file /usr/local/etcd-v3.5.0/conf/etcd.conf.yml >/usr/local/etcd-v3.5.0/log/etcd.log 2>&1 & + + 测试 + ETCDCTL_API=2 etcdctl + ETCDCTL_API=3 etcdctl +--- + + 关于客户端和CA证书的问题，etcdctl 是 客户端，而我们签发的证书都是服务端证书，所以访问服务端时候必须把z + --cacert=/usr/local/etcd-v3.5.0/ssl/ca.pem --cert=/usr/local/etcd-v3.5.0/ssl/server.pem --key=/usr/local/etcd-v3.5.0/ssl/server-key.pem + +--- + +## 4. 第4章 kubeadm + +bid: `2022060613040400000000000019` + +## kubernetes 第4章 kubeadm +### k8s 安装相关 doc +--- +[apiDoc](https://kubernetes.io/docs/reference/config-api/) +[docker centos install doc](https://docs.docker.com/engine/install/centos/) + +## 4.1 安装背景 +--- +腾讯云服务器，3台2G四核的不同网段的轻量云服务器（特价买的）。 +因为轻量云服务器采用的是VPC网络，所以通过ip addr 命令可以看到并没有公网网址。 +和一个网段私有网络不同，这里是需要公网ip的，所以做了一个临时的虚拟网卡： + +`4.1.1` 创建临时网卡先应付： + + # 每台机器都要做(临时网卡做法，永久性的暂时没测试) + ifconfig eth0:1 49.233.4.79 netmask 255.255.255.0 up + ifconfig eth0:1 43.138.55.43 netmask 255.255.255.0 up + ifconfig eth0:1 43.138.73.106 netmask 255.255.255.0 up + +`4.1.2` 腾讯云有两个网络访问安全的设置： + + # 添加 安全组 规则 放行所有6443 TCP端口 + # 防火前 添加 规则 ，放行 node1 node2 node3 的6443 TCP网络 + +`4.1.3` hostname修改 + + # hostname 修改 + hostnamectl set-hostname xx + +`4.1.4` 设置3台机器的网络连接： + + # 修改 /etc/hosts + vi /etc/hosts + + # 将以下内容添加即可 + 49.233.4.79 node1 + 43.138.55.43 node2 + 43.138.73.106 node3 + + # ping + ping node3 + +`4.1.5` 将 SELinux 设置为 permissive 模式（相当于将其禁用） + + sudo setenforce 0 + sudo sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config + +`4.1.6` 关闭swap + + swapoff -a + sed -ri 's/.*swap.*/#&/' /etc/fstab + +`4.1.7` 允许 iptables 检查桥接流量 + + cat < docker-ce-cli- containerd.io docker-compose-plugin + yum install docker-ce-20.10.17-3.el7 docker-ce-cli-20.10.17-3.el7 containerd.io docker-compose-plugin + + cat < /etc/yum.repos.d/kubernetes.repo + [kubernetes] + name=Kubernetes + baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64 + enabled=1 + gpgcheck=1 + repo_gpgcheck=0 + gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg + EOF + +`4.2.2` kubelet/kubectl/kubeadm download + + # 指定版本号最好 + yum -y install kubelet-1.23.7-0 kubeadm-1.23.7-0 kubectl-1.23.7-0 + # 如果原来存在多个版本，请删除,因为默认是使用高版本的，会导致无法加入node + yum -y remove kubeadm* kubelet* kubectl* + + systemctl enable kubelet.service + + # 修改 docker 的cgroup + # 添加以下内容 + vim /etc/docker/daemon.json + { + "exec-opts": ["native.cgroupdriver=systemd"] + } + # 重启docker + systemctl restart docker + docker info | grep Cgroup + + +### 4.3 kubeadm init + + # 创建集群，其他默认就可以，需要指定集群公网地址和CIDR局域网网段 + kubeadm init --apiserver-advertise-address 49.233.4.79 --pod-network-cidr=10.244.0.0/16 + + # 使集群生效， + mkdir -p $HOME/.kube + sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config + sudo chown $(id -u):$(id -g) $HOME/.kube/config + + # token 24h 过期 + kubeadm token create --print-join-command + # 查看集群master节点 + kubectl describe node node1 + + # 查看集群pods，我们会发现，coredns 一直处于Pending状态，这是符合预期的，因为我们还没有安装集群插件 + kubectl get pods -A + + # 安装集群插件 flannel + # https://github.com/flannel-io/flannel/blob/master/Documentation/kube-flannel.yml + kubectl apply -f kube-flannel.yaml + + # 安装集群网络插件 + kubectl apply -f https://docs.projectcalico.org/manifests/calico.yaml + + # 再查看集群pods，一定要先安装网络插件，再去添加集群节点哦。 + kubectl get pods -A + + # 加入worker节点 + # 由于不在一个内网，集群间通讯默认走内网ip，因此需要借助公网ip，通过iptables转换 + iptables -t nat -A OUTPUT -d -j DNAT --to-destination 青云内网ip + + + # 然后 kubeadm join 在其他node处添加进来。 + kubeadm join 49.233.4.79:6443 --token xx.xxx \ + --discovery-token-ca-cert-hash sha256:xxxxxxx + + # 到这一步集群节点就算完事了。 + +### 4.4 ETCD +--- + +`4.4.1` etcd ca + + # etcd 作为数据库 也有自己的ca，kubeadm 安装etcd时ca是存入以下路径 + /etc/kubernetes/pki/etcd/ + +`4.4.2` etcd comman + + 1. 查看ETCD集群中运行的ETCD pod + kubectl get pod -n kube-system | grep etcd + 2. 进入ETCD pod容器 + kubectl exec -it etcd-node1 -n kube-system -- /bin/sh + 3. 设置环境变量为v3 + export ETCDCTL_API=3 + 4. 查看 member list + ETCDCTL_API=3 etcdctl \ + --cacert=/etc/kubernetes/pki/etcd/ca.crt \ + --cert=/etc/kubernetes/pki/etcd/healthcheck-client.crt \ + --key=/etc/kubernetes/pki/etcd/healthcheck-client.key \ + member list + check perf + 4. 查看 key 需要加上cert才可以 + etcdctl get /registry/pods/kube-system/kube-flannel-ds-vnhrw + 5. 未查询简单化，添加别名 + # 别名列表 + alias -p + # 添加别名 + alias cls=clear + # 删除别名 + unalias 别名 + alias etc="/usr/local/bin/etcdctl --endpoints=https://127.0.0.1:2379 --cacert=/etc/kubernetes/pki/etcd/ca.crt --cert=/etc/kubernetes/pki/etcd/server.crt --key=/etc/kubernetes/pki/etcd/server.key" + 6. 查询所有的key + etcdctl get / --prefix --keys-only + 7. 查询flnanel配置 + etcdctl get /registry/configmaps/kube-system/kube-flannel-cfg + ETCD_ENABLE_V2=true + ETCDCTL_API=2 etcdctl ls /coreos.com/network/subnets/ + ETCDCTL_API=2 etcdctl cluster-health + ETCDCTL_API=2 etcdctl member list + ETCDCTL_API=3 etcdctl member list + ETCDCTL_API=3 etcdctl check perf + +### 4.5 各种错误的解决方法。 +--- + # 最典型的就是版本不统一导致的安装错误 + + [ERROR CRI]: container runtime is not running: output: time="2022-06-13T10:26:24+08:00" level=fatal msg="unable to determine runtime API version: rpc error: code = Unavailable desc = connection error: desc = \"transport: Error while dialing dial unix /var/run/containerd/containerd.sock: connect: no such file or directory\"" +详细过程如下： + +这个原因吧 是一开始 直接yum -y install docker 发生的错，后来用docker-ce 就直接修复了 + + [ERROR KubeletVersion]: the kubelet version is higher than the control plane version. This is not a supported version skew and may lead to a malfunctional cluster. Kubelet version: "1.24.1" Control plane version: "1.23.7" + yum -y remove kubelet + yum -y install kubelet-1.23.7 kubeadm-1.23.7 + +kubeadm init 时候会发现被墙了。 + + I0613 12:39:59.679221 18038 checks.go:859] pulling: k8s.gcr.io/coredns/coredns:v1.8.6 + [preflight] Some fatal errors occurred: + [ERROR ImagePull]: failed to pull image k8s.gcr.io/kube-apiserver:v1.23.7: output: Error response from daemon: Get "https://k8s.gcr.io/v2/": net/http: request canceled while waiting for connection (Client.Timeout exceeded while awaiting headers) +解决方案： https://www.cnblogs.com/lifan1998/p/14326761.html +DOCKERHUB_URL=registry.aliyuncs.com/google_containers +--- +kubeadm init 时候kubelet check 出错 + + [kubelet-check] It seems like the kubelet isn't running or healthy. + [kubelet-check] The HTTP call equal to 'curl -sSL http://localhost:10248/healthz' failed with error: Get "http://localhost:10248/healthz": dial tcp [::1]:10248: connect: connection refused. + +使用 journalctl -xeu kubelet查看错误信息，基本上是docker 的cgroup和k8s的cgroup不一致导致的。 +修改 docker 的cgroup + + 解决方法 + # 添加以下内容 + vim /etc/docker/daemon.json + { + "exec-opts": ["native.cgroupdriver=systemd"] + } + + # 重启docker + systemctl restart docker + docker info | grep Cgroup + # 重新初始化 + kubeadm reset # 先重置 + + +### 上述master节点完成后进入，worker node安装 +--- + + # 确保和主节点的kubeadm版本相同 + yum list --showduplicates kubeadm + yum -y install kubeadm-1.23.7-0 kubelet-1.23.7-0 kubectl-1.23.7-0 + systemctl enable kubelet.service + +### /proc/sys/net/bridge/bridge-nf-call-iptables contents are not set to 1 +错误 + + [ERROR FileContent–proc-sys-net-bridge-bridge-nf-call-iptables]: /proc/sys/net/bridge/bridge-nf-call-iptables contents are not set to 1 + [preflight] If you know what you are doing, you can make a check non-fatal with --ignore-preflight-errors=... + +解决方案 + + echo “1” >/proc/sys/net/bridge/bridge-nf-call-iptables + +--- + +## 5. 第5章 编排原理 + +bid: `2022060717000500000000000021` + +## kubernetes 第5章 编排原理 +### 污点 +--- +`taints：污点，定义在节点上，是键值数据` +`tolerations：容忍度，定义在pod上，可以定义能容忍哪些污点` + + + taints: + - effect: NoSchedule 不会被调度 + key: node-role.kubernetes.io/master + - effect: PreferNoSchedule 尽量不调度 + key: node-role.kubernetes.io/master + - effect: NoExecute 驱逐节点 + key: node-role.kubernetes.io/master + + tolerations: + - key: "key" + operator: "Equal" + value: "value" + effect: "NoSchedule" + + tolerations: + - key: "key" + operator: "Exists" + effect: "NoSchedule" + + 一个 toleration和一个 taint 相"匹配"是指它们有一样的key和effect + operator 默认是 Equal ，即value 相等才匹配 + +`master节点默认是有污点的可以通过以下命令查看` + + kubectl describe nodes node1 | grep Taints + Taints: node-role.kubernetes.io/master:NoSchedule + 该污点表示，不会被调度。 + + kubectl describe nodes node2 | grep Taints + Taints: + +`如何在master节点发布pod呢` + +--- + +## 6. 第7章 网络原理 + +bid: `2022060814410000000000000024` + +## +### 7.2 深入解析容器跨主机网络 +--- +为了解决容器跨主机通信问题，就一定要从Flannel项目说起。 +Flannel项目目前提供了三种实现： +（1）VXLAN +（2）host-gw了。 +（3）UDP +UDP是最早的支持的一种方式，但是，性能较差，已经弃用，但这种方式简单直接，也是最容易理解的一种容器跨主机网络实现。 +Flannel会在宿主机上创建一些列路由规则，flannel0 +flannel0是基于CIDR/16的，而docker0，eth0是基于CIDR/24的。并且flannel0设备类型很有意思，他是一个基于TUN设备（tunnel设备） +在linux中tunnel设备是在一种第三层（网络层）工作的virtual device。他的功能也非常简单，就是在操作系统内核和用户应用程序之间传递ip包。 +当操作系统，将一个Ip包发送给一个flannel0设备之后，flannel0会把这个ip包交给创建该设备的应用程序，也就是Flannel进程，这是一个内核态到用户态的流动方向。 +反之，如果Flannel进程，向flannel0设备发送了一个ip包，这个ip包会出现在 宿主机network stack 中，根据宿主机的路由表进行下一步处理。这是用户态向内核态的流动方向。 +还有一个重要概念subnet子网：事实上，一台主机上的所有容器都会被分配一个CIDR/24的子网，而主机和子网的映射关系保存在k8s的分布式存储etcd当中。 + + // 查看keys + $ etcdctl ls /coreos.com/network/subnets + /coreos.com/network/subnets/100.96.1.0-24 + /coreos.com/network/subnets/100.96.2.0-24 + /coreos.com/network/subnets/100.96.3.0-24 + + // 获取public ip + $ etcdctl get /coreos.com/network/subnets/100.96.2.0-24 + {"PublicIP": "10.168.0.3"} + +以上过程的总结： +容器确定source ip和 target ip，如果他们在一个CIDR/24下，则走的直连规则，如果不是一个子网段，则会把ip包通过docker0进入到宿主机ip route表中进行匹配，然后进入到flannel0设备中，flannel0 通过tunnel 把ip包转给flannel1d进程，然后通过etcd查询target的共有ip，并将ip包发出。 +当然，采用UDP得以实现的原因是，每台宿主机flannelid都监听着一个8285端口。 +当然这种方式，性能很差，差在tunnel设备需要三次用户态和内核态的切换，很肥资源。 +这也是Flannel 后来支持VXLAN的模式成为主流的网络解决方案。 + +### VXLAN（virtual extensible LAN 虚拟可扩展局域网） +--- +是linux本来就支持的网络虚拟化技术。 +VXLAN可以在完全在内核态上实现封装和解封的工作，从而构建UDP模式相似的网络。 +VXLAN是在二层网络上构建出的隧道模式，只不过对他进行封装和解封的对象是二层数据帧（ethernet frame），而且这个工作全部是在内核里完成，（因为VXLAN就是linux内核的一个模块） +但是为了解决发送时IP包并不知道MAC，所以需要维护一个ARP表 +可以通过命令去查看 + + $ ip neigh show dev flannel.1 + + +### 7.3 kubernetes网络模型与CNI网络插件 +--- +7.2的流程，是k8s对容器网络的处理方法。只不过k8s是通过一个叫做CNI的接口维护了一个单独的网桥来代替docker0.默认的设备名称cni0. +具体内容就不细说了， +### 7.4 解读kubernetes 三层网络方案 host-gw +-- +### 7.5 解读kubernetes 三层 +-- + +--- + +## 7. 第6章 存储原理 + +bid: `2022060814418900000000000023` + +kubernetes 第6章 存储原理 + +--- + +## 8. 第8章 调度与资源管理 + +bid: `2022060814420100000000000025` + +## kubernetes 第8章 调度与资源管理 +### 8.1 kubernetes 资源模型 +--- +- 可压缩资源（compressiable resources） + CPU，当他不足时，Pod只会饥饿，不会退出 +- 不可压缩资源（imcompressiable resources） + 内存，当他不足时，Pod会因为OOM被内核结束。 +由于Pod是可以由多个Containner组成，而每个Containner都是一个进程，所以Pod整体的资源配置是由Container所有进程资源配置累加的，同时资源配置是需要配置在Container上的。 +此外，k8s是允许，CPU设置成分数的，cpu=0.5或者cpu=500m这样的写法，才是k8s的内部通用表示法。 +内存的单位自然就是byte，注意区分MB和Mib +**※** 1MiB 1024x1024 1Mb=1000x1000 + + apiVersion: v1 + kind: Pod + metadata: + name: frontend + spec: + containers: + - name: db + image: mysql + env: + - name: MYSQL_ROOT_PASSWORD + value: "password" + resources: + requests: + memory: "64Mi" + cpu: "250m" + limits: + memory: "128Mi" + cpu: "500m" + - name: wp + image: wordpress + resources: + requests: + memory: "64Mi" + cpu: "250m" + limits: + memory: "128Mi" + cpu: "500m" + +关于limits和requests +区别： +调度时候，kube-scheduler只会按照requests的值去计算。 +而在真正设置Cgroups的时候，kubelet会按照limits去计算。 + +### qosclass类型 +--- +如果只定义了limits，那么k8s默认会将requests与limits设置一样， +qosclass字段会被k8s自动设置成Guaranteed +当Pod不满足Guaranteed，但至少有一个container设置了requests，k8s会将qosclass设置成Burstable +如果一个Pod既没有设置limits也没有设置requests，Qos的类型为BestEffort +**作用** +当宿主机资源紧张的时候，kubelet对Pod进行资源回收（Eviction）时候需要用到。具体来说，宿主机上不可压缩资源资源短缺时候，就有可能触发Eviction +目前Eviction的默认值如下： +memory.available<100Mi +nodefs.available<10% +nodefs.inodesFree<5% +imagefs.avaialble<15% +kubelet中是可以对上述Eviction进行配置的。 +配置时，有两种模式Soft和Hard， +而k8s计算Eviction的阈值数据来源，是通过Cgroup读取的值和cAdsivor监控到的数据。 +当宿主机的Eviction阈值达到后，会进入MemoryPressure或者DiskPressure状态，从而避免新的Pod被调度到这个宿主机。 + +**Eviction** +发生Eviction按照，BestEffort->Burstable(超过requests的容器)->Guaranteed + +**cpuset** +我们可以通过cpuset将容器绑定到某个CPU的核上，而不是像cpushare共享cpu计算能力。这样操作系统在cpu直接的切换会大大减少。 + +### 8.2 kubernetes 默认调度器 +--- +- default scheduler +默认调度器的主要职责是，为创建出来的Pod需找一个最合适的节点。 + +Node selection in kube-scheduler +kube-scheduler selects a node for the pod in a 2-step operation: +1. Filtering +2. Scoring + +根据算法选出，可调度的list，在根据算法从中选出最优。 +Predicate算法，检查每个节点是否可用 +Priority算法，给每个节点打分，得分最高的就是最终的调度结果。 +而，scheduler对Pod的调度成功体现在，他的spec.nodeName字段填上调度结果的节点名字。 + +### 8.3 kubernetes 默认调度器调度策略 +--- +- 调度策略 +- [doc](https://kubernetes.io/docs/reference/scheduling/policies/) +1. GeneralPredicates + +2. 与Volume相关的过滤策略 + NoDiskConflict检查多个Pod声明的PV是否有冲突，比如AWS EBS类型的Volume不允许被两个Pod同时使用。 + MaxPDVolumeCountPredicate检查一个节点某个类型的PV是否超过一定数量。 + +3. 宿主机相关的过滤策略 + NodeMemoryPressurePredicate +4. Pod相关的过滤策略 + PodAffinityPredicate + 亲密性affinity和反亲密性anti-affinity。 +## 8.4 kubernetes 默认调度器优先级和抢占机制 +--- +Priority和Preemption解决的是Pod调度失败后该怎么办的问题。 +提交一个priorityclass定义： + + apiVersion: scheduling.k8s.io/v1 + kind: PriorityClass + metadata: + name: high-priority + value: 1000000 + globleDefault: false + description: "~~~~" +默认的Pod的priority的value是0 +globleDefault是false意味着，不是默认的，需要在pod声明指定 +因为scheduler中维护了一个调度队列，当Pod中priority高的就有可能提前出队列，从而更早的完成调度过程。 +当一个高priority的Pod调度失败后，scheduler的抢占Preemption能力就会触发。 +scheduler 在调度队列中实现了两个不同的队列： +activeQ和unschedulableQ +activeQ中的Pod都是下一次调度周期需要调度的对象 +unschedulableQ存放的都是调度失败的Pod。 +当一个unschedulableQ发生更新后，k8s + +--- + +## 9. 第10章 资源 + +bid: `2022061515517700000000000028` + +## 1. ingress来龙去脉 +--- +[doc](https://kubernetes.io/zh-cn/docs/concepts/services-networking/ingress/) + +- Ingress-nginx quick start +[quick start](https://kubernetes.github.io/ingress-nginx/deploy/#quick-start) + +K8s集群对外暴露服务的方式目前只有三种: +- Loadblancer +- Nodeport +- ingress +- headerless + + +### ingress介绍 +--- +ingress由两部分组成 +- ingress +指的是k8s中的一个api对象，一般用yaml配置。作用是定义请求如何转发到service的规则，可以理解为配置模板。 + +- ingress controller +具体实现反向代理及负载均衡的程序，对ingress定义的规则进行解析，根据配置的规则来实现请求转发。 +ingress-controller并不是k8s自带的组件，实际上ingress-controller只是一个统称，用户可以选择不 同的ingress-controller实现 +目前，由k8s维护的ingress-controller只有google云的GCE与ingress-nginx两个，其他还有很多第三方维护的ingress-controller + +### ingress-controller 安装 +[参照](https://blog.csdn.net/weixin_38797137/article/details/124251698) + + # 先现在 配置文件 + wget https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.2.0/deploy/static/provider/cloud/deploy.yaml + # 由于国内被墙，有几个镜像是下载不下来的，所以修改deploy.yaml + vi deploy.yaml + # /image 查找镜像 + # 修改controller:v1.2.0 + bitnami/nginx-ingress-controller:1.2.0 + # 修改kube-webhook-certgen + registry.aliyuncs.com/google_containers/kube-webhook-certgen:v1.1.1 + # /externalTrafficPolicy + # 修改externalTrafficPolicy = Cluster + + # 最后 apply + kubectl apply -f deploy.yaml + + +### ingress tls 证书替换 + // [可以参考 linux 下的 nginx 证书使用](https://cloud.tencent.com/document/product/400/35244) + [root@node1 ~]# kubectl create secret tls https-secret2023 --cert=/usr/local/kubernetes/secret/violin-home.cn_bundle.crt --key=/usr/local/kubernetes/secret/violin-home.cn.key -n devops + [root@node1 ~]# kubectl get secret -A + [root@node1 ~]# kubectl edit ingress violin-ingress -n devops + +## 2. Service +--- +[doc](https://kubernetes.io/zh-cn/docs/concepts/services-networking/service/) + + + [root@node1 ~]# kubectl get svc -A + NAMESPACE NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE + default kubernetes ClusterIP 10.96.0.1 443/TCP 2d21h + kube-system kube-dns ClusterIP 10.96.0.10 53/UDP,53/TCP,9153/TCP 2d21h + +`先了解以下参与k8s网络的角色` + +- kube-dns +- kube-proxy +- kube-flannel-ds +- coredns +- cni0 +- controller + +--- + +## 10. 第11章 权限控制 + +bid: `2022061710512100000000000001` + +## RBAC规则 +--- +### 概念 +RBAC模型（Role-Based Access Control：基于角色的访问控制） +在RBAC模型里面，有3个基础组成部分，分别是：用户、角色和权限。 +- User（用户）：每个用户都有唯一的UID识别，并被授予不同的角色 +- Role（角色）：不同角色具有不同的权限 +- Permission（权限）：访问权限 + + + # user -> role <- Permission + 张三 管理员 增删改查 + 李四 普通用户 查 + 王五 普通用户 查 + +设置角色，然后对角色进行权限设置，然后将用户和角色关联即可。 +用户和权限没有必然关系，是通过角色去控制的 +### kubernetes 中的RBAC +RBAC规则包含ServiceAccount、ClusterRole、ClusterRoleBinding三类YAML文件，即三种对象 + +- **Service Account** +是面向命名空间的： + + apiVersion: v1 + kind: ServiceAccount + metadata: + name: beckend-serviceaccount + namespace: kube-users + +- **ClusterRole** +是面向整个集群所有命名空间的 +ClusterRole的一条规则由apiGroups、resources、verbs共同组成 +ClusterRole 用来描述 一个角色和他所拥有的权限 + + apiVersion: rbac.authorization.k8s.io/v1 + kind: ClusterRole + metadata: + name: namespace-readonly + rules: + - apiGroups: + - "" + resources: + - namespaces + verbs: + - get + - list + - watch + - apiGroups: + - metrics.k8s.io + resources: + - pods + verbs: + - get + - list + - watch + +- ClusterRoleBinding +是面向整个集群所有命名空间的 +ClusterRoleBinding中subjects是访问API的主体 +subjects包含users、groups、service accounts三种类型 +我们使用的是ServiceAccount类型 +ClusterRoleBinding 描述的是将 ServiceAccount（用户）和 ClusterRole（角色）jin'xing + + + apiVersion: rbac.authorization.k8s.io/v1 + kind: ClusterRoleBinding + metadata: + name: namespace-readonly-sa + roleRef: + apiGroup: rbac.authorization.k8s.io + kind: ClusterRole + name: namespace-readonly + subjects: + - apiGroup: rbac.authorization.k8s.io + kind: ServiceAccount + name: system:serviceaccounts:kube-users + +--- + +## 11. 基于虚拟网卡共有网络k8s集群搭建 + +bid: `2022062320127000000000000005` + +### linux +--- + +- port set + + 在腾讯云控制面对相应端口进行放行 + TCP 6443 + UDP 8472 + TCP 30000-32767 + +- SELinux 设置为 permissive 模式（相当于将其禁用） + + sudo setenforce 0 + sudo sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config + +- 关闭swap + + # 临时关闭swap分区，当前会话生效，重启失效 + swapoff -a + # 永久关闭swap分区 + sed -ri 's/.*swap.*/#&/' /etc/fstab + + +- 所有机器都要做 + + echo "1" >/proc/sys/net/bridge/bridge-nf-call-iptables + echo 1 > /proc/sys/net/ipv4/ip_forward + vi /etc/sysctl.conf + net.ipv4.ip_forward = 1 + + cat < /etc/sysconfig/network-scripts/ifcfg-eth0:1 < + PREFIX=32 + TYPE=Ethernet + USERCTL=no + ONBOOT=yes + EOF + + + +### 版本信息 +--- + kubernetes, kubelet, kubectl, kubeadm version + v1.23.7 + +### 修改kubelet( per machine) +--- + # 此文件安装kubeadm后就存在了 + vim /usr/lib/systemd/system/kubelet.service.d/10-kubeadm.conf + + # 注意，这步很重要，如果不做，节点仍然会使用内网IP注册进集群 + # 在末尾添加参数 --node-ip=公网IP + ExecStart=/usr/bin/kubelet $KUBELET_KUBECONFIG_ARGS $KUBELET_CONFIG_ARGS $KUBELET_KUBEADM_ARGS $KUBELET_EXTRA_ARGS --node-ip=<公网IP> + +### 编写启动配置文件 +--- + + # 添加配置文件，注意替换下面的IP + cat > kubeadm-config.yaml <bid: `2022070116141100000000000006` + +### 事前准备 +--- + +如果以前有安装过， 请清理掉 + + ll /usr/lib/systemd/system/kube* + + systemctl stop kube-apiserver + systemctl stop kube-controller-manager + systemctl stop kubelet + systemctl stop kube-proxy + systemctl stop kube-scheduler + + + 目录准备 + mkdir -p /usr/local/kubernetes/{bin,conf,ssl,logs} + +### kube-apiserver 安装 +--- + +`生成自签CA配置` + + cat > ca-config.json << EOF + { + "signing": { + "default": { + "expiry": "87600h" + }, + "profiles": { + "kubernetes": { + "expiry": "87600h", + "usages": [ + "signing", + "key encipherment", + "server auth", + "client auth" + ] + } + } + } + } + EOF + + cat > ca-csr.json << EOF + { + "CN": "kubernetes CA", + "key": { + "algo": "rsa", + "size": 2048 + }, + "names": [ + { + "C": "CN", + "L": "ShangHai", + "ST": "ShangHai", + "O": "k8s", + "OU": "system" + } + ] + } + EOF + + 生成CA + cfssl gencert -initca ca-csr.json | cfssljson -bare ca - +--- + +`给apiServer签发证书` + + cat > server-csr.json << EOF + { + "CN": "kubernetes", + "hosts": [ + "10.244.0.1", + "10.0.0.1", + "127.0.0.1", + "49.233.4.79", + "43.138.55.43", + "43.138.73.106", + "10.0.16.3", + "10.0.8.13", + "kubernetes", + "kubernetes.default", + "kubernetes.default.svc", + "kubernetes.default.svc.cluster", + "kubernetes.default.svc.cluster.local" + ], + "key": { + "algo": "rsa", + "size": 2048 + }, + "names": [ + { + "C": "CN", + "L": "ShangHai", + "ST": "ShangHai", + "O": "k8s", + "OU": "system" + } + ] + } + EOF + + cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes server-csr.json | cfssljson -bare server + + + 生成token + head -c 16 /dev/urandom | od -An -t x | tr -d ' ' + cat > /usr/local/kubernetes/conf/token.csv << EOF + f41424f202b2c2e71da40ce20d32f1d2,kubelet-bootstrap,10001,"system:node-bootstrapper" + EOF +--- + + cat > /usr/lib/systemd/system/kube-apiserver.service << EOF + [Unit] + Description=Kubernetes API Server + Documentation=https://github.com/kubernetes/kubernetes + + [Service] + EnvironmentFile=/usr/local/kubernetes/conf/kube-apiserver.conf + ExecStart=/usr/local/kubernetes/bin/kube-apiserver \$KUBE_APISERVER_OPTS + Restart=on-failure + + [Install] + WantedBy=multi-user.target + EOF +--- + + vi kube-apiserver.conf + + KUBE_APISERVER_OPTS="--logtostderr=false \ + --v=2 \ + --log-dir=/usr/local/kubernetes/logs \ + --etcd-servers=https://49.233.4.79:2379,https://43.138.55.43:2379,https://43.138.73.106:2379 \ + --bind-address=49.233.4.79 \ + --secure-port=6443 \ + --advertise-address=49.233.4.79 \ + --allow-privileged=true \ + --service-cluster-ip-range=10.0.0.0/16 \ + --enable-admission-plugins=NamespaceLifecycle,LimitRanger,ServiceAccount,ResourceQuota,NodeRestriction \ + --authorization-mode=RBAC,Node \ + --enable-bootstrap-token-auth=true \ + --token-auth-file=/usr/local/kubernetes/conf/token.csv \ + --service-node-port-range=30000-32767 \ + --kubelet-client-certificate=/usr/local/kubernetes/ssl/server.pem \ + --kubelet-client-key=/usr/local/kubernetes/ssl/server-key.pem \ + --tls-cert-file=/usr/local/kubernetes/ssl/server.pem \ + --tls-private-key-file=/usr/local/kubernetes/ssl/server-key.pem \ + --client-ca-file=/usr/local/kubernetes/ssl/ca.pem \ + --service-account-key-file=/usr/local/kubernetes/ssl/ca-key.pem \ + --service-account-issuer=api \ + --service-account-signing-key-file=/usr/local/kubernetes/ssl/server-key.pem \ + --etcd-cafile=/usr/local/etcd-v3.5.0/ssl/ca.pem \ + --etcd-certfile=/usr/local/etcd-v3.5.0/ssl/server.pem \ + --etcd-keyfile=/usr/local/etcd-v3.5.0/ssl/server-key.pem \ + --requestheader-client-ca-file=/usr/local/kubernetes/ssl/ca.pem \ + --proxy-client-cert-file=/usr/local/kubernetes/ssl/server.pem \ + --proxy-client-key-file=/usr/local/kubernetes/ssl/server-key.pem \ + --requestheader-allowed-names=kubernetes \ + --requestheader-extra-headers-prefix=X-Remote-Extra- \ + --requestheader-group-headers=X-Remote-Group \ + --requestheader-username-headers=X-Remote-User \ + --enable-aggregator-routing=true \ + --audit-log-maxage=30 \ + --audit-log-maxbackup=3 \ + --audit-log-maxsize=100 \ + --audit-log-path=/usr/local/kubernetes/logs/k8s-audit.log" + +--- + + # 刷新设置，并设置开机启动，查看status + systemctl daemon-reload + systemctl start kube-apiserver + systemctl enable kube-apiserver + systemctl status kube-apiserver -l + + +### kube-controller-manager 安装 +--- +`创建配置文件` + + cat > /usr/local/kubernetes/conf/kube-controller-manager.conf << EOF + KUBE_CONTROLLER_MANAGER_OPTS="--logtostderr=false \\ + --v=2 \\ + --log-dir=/usr/local/kubernetes/logs \\ + --leader-elect=true \\ + --kubeconfig=/usr/local/kubernetes/conf/kube-controller-manager.kubeconfig \\ + --bind-address=127.0.0.1 \\ + --allocate-node-cidrs=true \\ + --cluster-cidr=10.244.0.0/16 \\ + --service-cluster-ip-range=10.0.0.0/16 \\ + --cluster-signing-cert-file=/usr/local/kubernetes/ssl/ca.pem \\ + --cluster-signing-key-file=/usr/local/kubernetes/ssl/ca-key.pem \\ + --root-ca-file=/usr/local/kubernetes/ssl/ca.pem \\ + --service-account-private-key-file=/usr/local/kubernetes/ssl/ca-key.pem \\ + --cluster-signing-duration=87600h0m0s" + EOF + + +--- +`生成证书` + + cd /usr/local/kubernetes/ssl + cat > kube-controller-manager-csr.json << EOF + { + "CN": "system:kube-controller-manager", + "hosts": [], + "key": { + "algo": "rsa", + "size": 2048 + }, + "names": [ + { + "C": "CN", + "L": "ShangHai", + "ST": "ShangHai", + "O": "system:masters", + "OU": "System" + } + ] + } + EOF + + cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-controller-manager-csr.json | cfssljson -bare kube-controller-manager + + ll + +`生成kubeconfig文件` + + KUBE_CONFIG="/usr/local/kubernetes/conf/kube-controller-manager.kubeconfig" + KUBE_APISERVER="https://49.233.4.79:6443" + + kubectl config set-cluster kubernetes \ + --certificate-authority=/usr/local/kubernetes/ssl/ca.pem \ + --embed-certs=true \ + --server=${KUBE_APISERVER} \ + --kubeconfig=${KUBE_CONFIG} + + kubectl config set-credentials kube-controller-manager \ + --client-certificate=/usr/local/kubernetes/ssl/kube-controller-manager.pem \ + --client-key=/usr/local/kubernetes/ssl/kube-controller-manager-key.pem \ + --embed-certs=true \ + --kubeconfig=${KUBE_CONFIG} + + kubectl config set-context default \ + --cluster=kubernetes \ + --user=kube-controller-manager \ + --kubeconfig=${KUBE_CONFIG} + + kubectl config use-context default --kubeconfig=${KUBE_CONFIG} + + ll /usr/local/kubernetes/conf +--- + +`systemd管理controller-manager` + + cat > /usr/lib/systemd/system/kube-controller-manager.service << EOF + [Unit] + Description=Kubernetes Controller Manager + Documentation=https://github.com/kubernetes/kubernetes + + [Service] + EnvironmentFile=/usr/local/kubernetes/conf/kube-controller-manager.conf + ExecStart=/usr/local/kubernetes/bin/kube-controller-manager \$KUBE_CONTROLLER_MANAGER_OPTS + Restart=on-failure + + [Install] + WantedBy=multi-user.target + EOF +--- +`启动并设置开机自启` + + systemctl daemon-reload + systemctl start kube-controller-manager + systemctl enable kube-controller-manager + systemctl status kube-controller-manager -l + + + +### kube-scheduler 安装 +--- +`创建配置文件` + + cat > /usr/local/kubernetes/conf/kube-scheduler.conf << EOF + KUBE_SCHEDULER_OPTS="--logtostderr=false \\ + --v=2 \\ + --log-dir=/usr/local/kubernetes/logs \\ + --leader-elect \\ + --kubeconfig=/usr/local/kubernetes/conf/kube-scheduler.kubeconfig \\ + --bind-address=127.0.0.1" + EOF +--- +`生成kubeconfig文件` + + cd /usr/local/kubernetes/ssl + + cat > kube-scheduler-csr.json << EOF + { + "CN": "system:kube-scheduler", + "hosts": [], + "key": { + "algo": "rsa", + "size": 2048 + }, + "names": [ + { + "C": "CN", + "L": "ShangHai", + "ST": "ShangHai", + "O": "system:masters", + "OU": "System" + } + ] + } + EOF + + cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-scheduler-csr.json | cfssljson -bare kube-scheduler + + ll +--- +`生成kubeconfig文件 ` + + KUBE_CONFIG="/usr/local/kubernetes/conf/kube-scheduler.kubeconfig" + KUBE_APISERVER="https://49.233.4.79:6443" + + kubectl config set-cluster kubernetes \ + --certificate-authority=/usr/local/kubernetes/ssl/ca.pem \ + --embed-certs=true \ + --server=${KUBE_APISERVER} \ + --kubeconfig=${KUBE_CONFIG} + + kubectl config set-credentials kube-scheduler \ + --client-certificate=/usr/local/kubernetes/ssl/kube-scheduler.pem \ + --client-key=/usr/local/kubernetes/ssl/kube-scheduler-key.pem \ + --embed-certs=true \ + --kubeconfig=${KUBE_CONFIG} + + kubectl config set-context default \ + --cluster=kubernetes \ + --user=kube-scheduler \ + --kubeconfig=${KUBE_CONFIG} + + kubectl config use-context default --kubeconfig=${KUBE_CONFIG} + +--- +`systemd管理scheduler` + + cat > /usr/lib/systemd/system/kube-scheduler.service << EOF + [Unit] + Description=Kubernetes Scheduler + Documentation=https://github.com/kubernetes/kubernetes + + [Service] + EnvironmentFile=/usr/local/kubernetes/conf/kube-scheduler.conf + ExecStart=/usr/local/kubernetes/bin/kube-scheduler \$KUBE_SCHEDULER_OPTS + Restart=on-failure + + [Install] + WantedBy=multi-user.target + EOF + +--- +`启动并设置开机启动` + + systemctl daemon-reload + systemctl start kube-scheduler + systemctl enable kube-scheduler + systemctl status kube-scheduler -l + +--- + +### kubectl 安装 +--- + +`生成kubectl连接集群的证书` + + cd /usr/local/kubernetes/ssl + cat > admin-csr.json < kubelet <-> pod` +--- +`创建服务` + + + cat > /usr/lib/systemd/system/kubelet.service << EOF + [Unit] + Description=Kubernetes Kubelet + After=docker.service + + [Service] + EnvironmentFile=/usr/local/kubernetes/conf/kubelet.conf + ExecStart=/usr/local/kubernetes/bin/kubelet \$KUBELET_OPTS + Restart=on-failure + LimitNOFILE=65536 + + [Install] + WantedBy=multi-user.target + EOF +--- +`创建服务配置文件` + + cat > /usr/local/kubernetes/conf/kubelet.conf << EOF + KUBELET_OPTS="--logtostderr=false \\ + --v=2 \\ + --log-dir=/usr/local/kubernetes/logs \\ + --network-plugin=cni \\ + --hostname-override=k8s-master1 \\ + --kubeconfig=/usr/local/kubernetes/conf/kubelet.kubeconfig \\ + --bootstrap-kubeconfig=/usr/local/kubernetes/conf/bootstrap.kubeconfig \\ + --config=/usr/local/kubernetes/conf/kubelet-config.yml \\ + --cert-dir=/usr/local/kubernetes/ssl \\ + --pod-infra-container-image=k8s.gcr.io/pause:3.6" + EOF + +--- +`创建k8s kubelet资源文件` + + cat > /usr/local/kubernetes/conf/kubelet-config.yml << EOF + kind: KubeletConfiguration + apiVersion: kubelet.config.k8s.io/v1beta1 + address: 0.0.0.0 + port: 10250 + readOnlyPort: 10255 + cgroupDriver: systemd + clusterDNS: + - 10.0.0.2 + clusterDomain: cluster.local + failSwapOn: false + authentication: + anonymous: + enabled: false + webhook: + cacheTTL: 2m0s + enabled: true + x509: + clientCAFile: /usr/local/kubernetes/ssl/ca.pem + authorization: + mode: Webhook + webhook: + cacheAuthorizedTTL: 5m0s + cacheUnauthorizedTTL: 30s + evictionHard: + imagefs.available: 15% + memory.available: 100Mi + nodefs.available: 10% + nodefs.inodesFree: 5% + maxOpenFiles: 1000000 + maxPods: 110 + EOF + +--- + KUBE_CONFIG="/usr/local/kubernetes/conf/bootstrap.kubeconfig" + KUBE_APISERVER="https://49.233.4.79:6443" # apiserver IP:PORT + TOKEN="f41424f202b2c2e71da40ce20d32f1d2" # 与token.csv里保持一致 /usr/local/kubernetes/conf/token.csv + + # 生成 kubelet bootstrap kubeconfig 配置文件 + kubectl config set-cluster kubernetes \ + --certificate-authority=/usr/local/kubernetes/ssl/ca.pem \ + --embed-certs=true \ + --server=${KUBE_APISERVER} \ + --kubeconfig=${KUBE_CONFIG} + + kubectl config set-credentials "kubelet-bootstrap" \ + --token=${TOKEN} \ + --kubeconfig=${KUBE_CONFIG} + + kubectl config set-context default \ + --cluster=kubernetes \ + --user="kubelet-bootstrap" \ + --kubeconfig=${KUBE_CONFIG} + + kubectl config use-context default --kubeconfig=${KUBE_CONFIG} + + ll + +--- + + systemctl daemon-reload + systemctl stop kubelet + systemctl start kubelet + systemctl enable kubelet + systemctl status kubelet -l + +--- + + kubectl get csr + + kubectl certificate approve node-csr-KbHieprZUMOvTFMHGQ1RNTZEhsSlT5X6wsh2lzfUry4 + certificatesigningrequest.certificates.k8s.io/node-csr-KbHieprZUMOvTFMHGQ1RNTZEhsSlT5X6wsh2lzfUry4 approved + +--- + +`部署kube-proxy` + + cat > /usr/local/kubernetes/conf/kube-proxy.conf << EOF + KUBE_PROXY_OPTS="--logtostderr=false \\ + --v=2 \\ + --log-dir=/usr/local/kubernetes/logs \\ + --config=/usr/local/kubernetes/conf/kube-proxy-config.yml" + EOF + +--- + + cat > /usr/local/kubernetes/conf/kube-proxy-config.yml << EOF + kind: KubeProxyConfiguration + apiVersion: kubeproxy.config.k8s.io/v1alpha1 + bindAddress: 0.0.0.0 + metricsBindAddress: 0.0.0.0:10249 + clientConnection: + kubeconfig: /usr/local/kubernetes/conf/kube-proxy.kubeconfig + hostnameOverride: k8s-master1 + clusterCIDR: 10.244.0.0/16 + EOF + +--- + + cd /usr/local/kubernetes/ssl + + cat > kube-proxy-csr.json << EOF + { + "CN": "system:kube-proxy", + "hosts": [], + "key": { + "algo": "rsa", + "size": 2048 + }, + "names": [ + { + "C": "CN", + "L": "ShangHai", + "ST": "ShangHai", + "O": "k8s", + "OU": "System" + } + ] + } + EOF + + cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-proxy-csr.json | cfssljson -bare kube-proxy + ll + + +--- + +`生成kube-proxy.kubeconfig文件` + + KUBE_CONFIG="/usr/local/kubernetes/conf/kube-proxy.kubeconfig" + KUBE_APISERVER="https://49.233.4.79:6443" + + kubectl config set-cluster kubernetes \ + --certificate-authority=/usr/local/kubernetes/ssl/ca.pem \ + --embed-certs=true \ + --server=${KUBE_APISERVER} \ + --kubeconfig=${KUBE_CONFIG} + + kubectl config set-credentials kube-proxy \ + --client-certificate=/usr/local/kubernetes/ssl/kube-proxy.pem \ + --client-key=/usr/local/kubernetes/ssl/kube-proxy-key.pem \ + --embed-certs=true \ + --kubeconfig=${KUBE_CONFIG} + + kubectl config set-context default \ + --cluster=kubernetes \ + --user=kube-proxy \ + --kubeconfig=${KUBE_CONFIG} + + kubectl config use-context default --kubeconfig=${KUBE_CONFIG} + +--- + + cat > /usr/lib/systemd/system/kube-proxy.service << EOF + [Unit] + Description=Kubernetes Proxy + After=network.target + + [Service] + EnvironmentFile=/usr/local/kubernetes/conf/kube-proxy.conf + ExecStart=/usr/local/kubernetes/bin/kube-proxy \$KUBE_PROXY_OPTS + Restart=on-failure + LimitNOFILE=65536 + + [Install] + WantedBy=multi-user.target + EOF + +--- + + systemctl daemon-reload + systemctl stop kube-proxy + systemctl start kube-proxy + systemctl enable kube-proxy + systemctl status kube-proxy -l + +--- + +## 13. kubernetes Calico 配置 + +bid: `2022070223079600000000000007` + +### 官方网站 +--- +该插件与kubernetes版本对应。 +https://projectcalico.docs.tigera.io/archive/v3.20/getting-started/kubernetes/requirements + +### 安装 +--- +安装文档 +https://projectcalico.docs.tigera.io/archive/v3.23/getting-started/kubernetes/self-managed-onprem/onpremises#install-calico-with-kubernetes-api-datastore-50-nodes-or-less + +### 填坑 +--- + +`` + + rm -rf /etc/cni/net.d/* + rm -rf /var/lib/cni/calico + systemctl restart kubelet + + systemctl stop kubelet + systemctl stop docker + rm -rf /var/lib/cni/ + rm -rf /var/lib/kubelet/* + rm -rf + ifconfig cni0 down + ifconfig flannel.1 down + ifconfig docker0 down + iptb + ip link delete cni0 + ip link delete flannel.1 + systemctl start docker + systemctl start kubelet + + + +`关于污点和容忍` + + kubectl taint node k8s-master1 node.kubernetes.io/not-ready- + +`` + + + cat > apiserver-to-kubelet-rbac.yaml << EOF + apiVersion: rbac.authorization.k8s.io/v1 + kind: ClusterRole + metadata: + annotations: + rbac.authorization.kubernetes.io/autoupdate: "true" + labels: + kubernetes.io/bootstrapping: rbac-defaults + name: system:kube-apiserver-to-kubelet + rules: + - apiGroups: + - "" + resources: + - nodes/proxy + - nodes/stats + - nodes/log + - nodes/spec + - nodes/metrics + - pods/log + verbs: + - "*" + --- + apiVersion: rbac.authorization.k8s.io/v1 + kind: ClusterRoleBinding + metadata: + name: system:kube-apiserver + namespace: "" + roleRef: + apiGroup: rbac.authorization.k8s.io + kind: ClusterRole + name: system:kube-apiserver-to-kubelet + subjects: + - apiGroup: rbac.authorization.k8s.io + kind: User + name: kubernetes + EOF + + kubectl apply -f apiserver-to-kubelet-rbac.yaml + +ー－－ + +--- + +## 14. kubernetes 二进制安装worker + +bid: `2022070314528700000000000008` + +### kubelet +--- +`kubelet是 kubernetes 工作节点上的一个代理组件，运行在每个节点上。由于我的三台服务都是工作节点，所以也都需要装kubelet和kube-proxy` +`apiserver <-> kubelet <-> pod` +--- +`创建服务` + + + cat > /usr/lib/systemd/system/kubelet.service << EOF + [Unit] + Description=Kubernetes Kubelet + After=docker.service + + [Service] + EnvironmentFile=/usr/local/kubernetes/conf/kubelet.conf + ExecStart=/usr/local/kubernetes/bin/kubelet \$KUBELET_OPTS + Restart=on-failure + LimitNOFILE=65536 + + [Install] + WantedBy=multi-user.target + EOF +--- +`创建服务配置文件` + + cat > /usr/local/kubernetes/conf/kubelet.conf << EOF + KUBELET_OPTS="--logtostderr=false \\ + --v=2 \\ + --log-dir=/usr/local/kubernetes/logs \\ + --network-plugin=cni \\ + --hostname-override=k8s-node3 \\ + --kubeconfig=/usr/local/kubernetes/conf/kubelet.kubeconfig \\ + --bootstrap-kubeconfig=/usr/local/kubernetes/conf/bootstrap.kubeconfig \\ + --config=/usr/local/kubernetes/conf/kubelet-config.yml \\ + --cert-dir=/usr/local/kubernetes/ssl \\ + --pod-infra-container-image=k8s.gcr.io/pause:3.6" + EOF + +--- +`创建k8s kubelet资源文件` + + cat > /usr/local/kubernetes/conf/kubelet-config.yml << EOF + kind: KubeletConfiguration + apiVersion: kubelet.config.k8s.io/v1beta1 + address: 0.0.0.0 + port: 10250 + readOnlyPort: 10255 + cgroupDriver: systemd + clusterDNS: + - 10.0.0.2 + clusterDomain: cluster.local + failSwapOn: false + authentication: + anonymous: + enabled: false + webhook: + cacheTTL: 2m0s + enabled: true + x509: + clientCAFile: /usr/local/kubernetes/ssl/ca.pem + authorization: + mode: Webhook + webhook: + cacheAuthorizedTTL: 5m0s + cacheUnauthorizedTTL: 30s + evictionHard: + imagefs.available: 15% + memory.available: 100Mi + nodefs.available: 10% + nodefs.inodesFree: 5% + maxOpenFiles: 1000000 + maxPods: 110 + EOF + +--- + KUBE_CONFIG="/usr/local/kubernetes/conf/bootstrap.kubeconfig" + KUBE_APISERVER="https://49.233.4.79:6443" # apiserver IP:PORT + TOKEN="47d803a011a25fee21cc2fa434c391aa" # 与token.csv里保持一致 /opt/kubernetes/cfg/token.csv + + # 生成 kubelet bootstrap kubeconfig 配置文件 + kubectl config set-cluster kubernetes \ + --certificate-authority=/usr/local/kubernetes/ssl/ca.pem \ + --embed-certs=true \ + --server=${KUBE_APISERVER} \ + --kubeconfig=${KUBE_CONFIG} + + kubectl config set-credentials "kubelet-bootstrap" \ + --token=${TOKEN} \ + --kubeconfig=${KUBE_CONFIG} + + kubectl config set-context default \ + --cluster=kubernetes \ + --user="kubelet-bootstrap" \ + --kubeconfig=${KUBE_CONFIG} + + kubectl config use-context default --kubeconfig=${KUBE_CONFIG} + +--- + + systemctl daemon-reload + systemctl stop kubelet + systemctl start kubelet + systemctl enable kubelet + systemctl status kubelet -l + +--- diff --git a/AI/mechine learning/深入理解Java虚拟机.md b/AI/mechine learning/深入理解Java虚拟机.md new file mode 100644 index 0000000..f67627f --- /dev/null +++ b/AI/mechine learning/深入理解Java虚拟机.md @@ -0,0 +1,351 @@ +# 深入理解Java虚拟机 + +> 来源：原 mongodb 集合 `t_blog` · 整理日期：2026-08-25 +> 分类 ID：`00000000000003` · 排序：0 · 文章数：9 + +## 目录 + +1. [谈一下垃圾回收算法](#谈一下垃圾回收算法) +2. [Jvm](#jvm) +3. [2.1运行时数据区域](#21运行时数据区域) +4. [2.2对象内存](#22对象内存) +5. [13.1线程安全与锁优化](#131线程安全与锁优化) +6. [12.1Java内存模型和线程](#121java内存模型和线程) +7. [12.2关键字volatile](#122关键字volatile) +8. [12.3 原子性，可见性，有序性](#123-原子性可见性有序性) +9. [12.4 Happens-Before](#124-happens-before) + +--- + +## 1. 谈一下垃圾回收算法 + +bid: `00000000000001` + +## Garbage Collection アルゴリズム ## +--- +[参考文章](https://blog.csdn.net/Extraordinarylife/article/details/124309502) + +  对于Java开发人员来说，失去了引用的对象通常会被GC回收，而我们的方法都是我们的虚拟机栈中执行的，方法执行完毕后，引用被销毁，剩余的对象自然而然就是会被GC回收。 +就如参考文章所说，JVM种虚拟机栈是随线程开启而创建，线程销毁而结束。 +  由于新的垃圾回收器G1的的出现，和方法区（永久代）的废弃，取而代之的metaspace的出现，以往的游戏知识已过时。但是其中的基本算法思想还是学要学习的。 + +基本算法思想： +### 标记-清除（mark-sweep） +--- +标记是一个过程，他是通过**可达性分析算法**来实现的。 +这里标记的通常是不被清除的对象，因为这样的对象很少。因为大多数对象的都是一次性的。 +清除也是一个过程，它是基于**分代收集理论**实现的。清除未被标记的对象。 +这种算法很明显会产生内存碎片化，内存不连续会直接导致提前gc的发生。 + +为了避免内存的碎片化，就有了复制算法。 +### 复制算法 +--- +复制算法是建立在标记清除算法的基础上的（即也存在标记和清除的过程）。 +标记存活对象，复制对象到存活区，清除其他区域所有对象。 +复制算法，既然是复制，就要保证左右两边的容量相等，否则会出现数组越界等情况。 +这种算法典型用在年轻代的minor gc上。 +基于这种算法，jvm内存 配分成eden，s0和s1，8：1：1的比例。 +其中s0和s1的0和1没有任何区别。这样的设计比例较好的保证了大部分对象的产生和一小部分的对象进入存活区。虽然牺牲了1的部分的空间。 +new 出来的对象都会在eden中，当eden满了后，触发minor gc， +将存活对象移动到s0，清除eden，当eden第二次满了之后，将存活对象复制到s1，清除eden和s0，以后反复如此。 +### a + +--- + +## 2. Jvm + +bid: `00000000000004` + +# Jvm # +--- +Java Virtual Machine（Jvm）Java虚拟机 +是跨平台的关键因素。 +对于Jvm需要了解的有两大模块，一是内存模型，二是垃圾回收机制。 +## 内存模型 ## +--- +随着Java的版本的变化，内存模型也有一定的变化。 +比如Java8后，Metaspace代替了permanent space。 +但是内存模型这个抽象概念没有消失，java虚拟机内存通常被划分为以下几个部分。 +heap: +stack: +native method stack +程序计数器 + +## 垃圾回收机制/Garbage collections ## +--- +垃圾回收机制包括算法部分和堆内存分配两部分。 +heap内存：按照java的对象的存活时间分为以下几个部分。 +Young Generation： +Old Generation： +由于Meta Space是使用本地内存，他不算到heap里面。 +Eden space：所有的 + +--- + +## 3. 2.1运行时数据区域 + +bid: `2022050519382600000000000012` + +### 1.程序计数器（Program Counter Register） +--- +**线程独有**：用于记录线程的指令位置（内存地址）。 + 如果线程正在执行的是一个java方法，那么程序计数器记录的正在执行的虚拟机字节码指令的地址；如果，正在执行的是本地Native方法，这个计数器的值应该为空（Undefined）。 +此内存区域是《Java虚拟机规范》中唯一没有规定OutofMemoryError的区域。 + +### 2.虚拟机栈（Java Virtual Machine Stack） +--- +**线程独有**：是Java方法执行的内存模型。 + 每一个方法被执行的时候，Jvm会为该方法在该线程中创建一个栈帧（Stack Frame），用于存储 **局部变量表**，**操作数栈**，**动态链接**，**方法出口**等信息。 + 一个方法被调用，即为入栈（压栈），一个方法调用结束，即为出栈（弹栈）。不难发现栈是一个先进后出的QUEUE。 +局部变量表中存放了编译器可知的基本类型，对象引用，returnAddress类型（指向一条字节码指令的地址）。 + 这些数据类型在局部变量表中的存储空间以局部变量槽（Slot）表示。其中64位的long和double需要两个槽。其余的数据类型只占一个Slot，局部变量表的所需的内存空间在编译期间完成分配，当进入一个方法后，方法需要在栈帧中分配的变量空间是完全确定的。这个“大小”是指的槽的数量。真正一个槽多大空间是虚拟机决定的。 + 虚拟机栈中有两个异常：一个是，StackOverFlowError，栈深度异常。另一个是OutofMemoryError，是可选的（当如果虚拟机栈可以动态扩展，但又申请不到足够内存时，发生，HotSpot虚拟机不允许，动态扩展）。 + +### 3.本地方法栈 +--- +**线程独有**：是Java native方法执行的空间区域。 + 本地方法栈和虚拟机的作用是极其相识的，只是本地方法栈只为native method服务。 + +### 4.Java 堆 +--- +**线程共享**：是Java对象和数组的存放的主要区域。 + heap，随着java的技术的进步，所有的对象和数组都分配在堆中的z，已经不是那么绝对了。 +但是java垃圾回收器管理的区域就是堆。 +由于垃圾回收算法是基于分代类论的，但是随着java的垃圾回收技术的提升，堆的分配已经复杂化了，至少在G1垃圾回收器目前来看。 + +### 5.方法区 +--- +《Java虚拟机规范中的》的Non-heap。 +线程共享：存储已被虚拟机加载的类型信息，常量，静态变量，即时编译器编译后的代码缓冲的数据。 +其中运行时常量池作 + +### 6.直接内存 +--- + 既不是，运行时数据的一部分，也不是《虚拟机规范》中定义的区域，但这部分内存也会被频繁使用，而且可能导致OutOfMemoryError。 +JDK1.4加入了NIO类，引入了一种基于通道（channel）和缓冲区（buffer）的I/O模型，它可以使用native 方法直接分配堆外内存，然后通过Java堆中的DirectByteBuffer对象，作为这块内存的引用来进行操作，从而避免了Java堆和Native堆中的来回复制。 + +--- + +## 4. 2.2对象内存 + +bid: `2022050620338300000000000015` + +在HotSpot虚拟机里，对象在堆中的存储布局可以划分为三个部分：对象头（Header），实例数据（Instance Data）和对齐填充（Padding） + +#### 对象头（Header） +--- +对象头部包括两类信息，一类是用来存储对象自身的运行时数据，包括HashCode，GC分代年龄，锁状态标志，线程持有的锁，偏向线程ID，这里的偏向是指 offset，毕竟引用所指向的对象位置不是一个区域，而是一个点。 +这部分数据长度在32/64中的长度为，4个和8个字节，被称为Mark Word。 +比如在32位下，对象未被同步锁的情况下。 +| 存储内容 | bit | state | +| - | - | - | +| HashCode | 25 | | +| 分代年龄 | 4 | | +| 存储锁标志位 | 2 | | +| 固定为0 | 1 | | + +--- + +## 5. 13.1线程安全与锁优化 + +bid: `2022050710179900000000000027` + +## synchronized + + 既可以用作对象锁也可以用做类锁 + +## 类锁和对象锁 + + synchronized 对象锁： 每个对象都有一个monitor，而一个monitor只能被一个线程所拥有，当一个线程a进入monitorenter，monitor的进入数为1，同时，其他的线程就无法获取monitor，如果a再次进入monitorenter，monitor的进入数为2，所以synchronized 是可重入锁。当a monitorexit退出对象锁，则monitor的进入数减少为1，只有monitor的进入数为0时候，即没有任何线程拥有monitor + + 对象锁 + synchronizded method // 直接获取该方法的对象的对象锁 + synchronizded(object) { // 获取object的对象锁 + } + + 类锁 + static synchronizded method + synchronizded(xxx.class) { + } + + -- 类锁和对象锁不会产生竞争，二者的加锁方法不会相互影响 + +## 锁在哪？ biased lock 偏向锁 + + 我们知道java对象有三部分组成 + 对象头部 object header + 实例数据 object data + 对齐填充 向2的*n填充 + + 而对象头部由Mark Word和klass pointer组成 + 前8个字节为Mark Word，后4个字节为klass pointer + 其中Mark Word长度为jvm一个word的大小。64位jvm是64bit，即8个字节。 + ------------------------------------------------- + OFFSET SIZE TYPE DESCRIPTION + 0 4 (object header) markword + 0 4 (object header) markword + 8 4 (object header) klass pointer + ------------------------------------------------- + [open jdk document](http://hg.openjdk.java.net/jdk8/jdk8/hotspot/file/87ee5ee27509/src/share/vm/oops/markOop.hpp) + + // 64 bits: + // -------- + // unused:25 hash:31 -->| unused:1 age:4 biased_lock:1 lock:2 (normal object) + // JavaThread*:54 epoch:2 unused:1 age:4 biased_lock:1 lock:2 (biased object) + // PromotedObject*:61 --------------------->| promo_bits:3 ----->| (CMS promoted object) + // size:64 ----------------------------------------------------->| (CMS free block) + // + // unused:25 hash:31 -->| cms_free:1 age:4 biased_lock:1 lock:2 (COOPs && normal object) + // JavaThread*:54 epoch:2 cms_free:1 age:4 biased_lock:1 lock:2 (COOPs && biased object) + // narrowOop:32 unused:24 cms_free:1 unused:4 promo_bits:3 ----->| (COOPs && CMS promoted object) + // unused:21 size:35 -->| cms_free:1 unused:7 ------------------>| (COOPs && CMS free block) + + unused hash unused age biased_lock lock + 25 -> 31 -> 1 -> 4 -> 1 -> 2 normal object(sum = 64) + + + 无锁状态下的mark word + Java 对象刚创建时，还没有任何线程来竞争 + unused hash unused age biased_lock lock + 25 -> 31 -> 1 -> 4 -> 0 -> 01 + + 偏向状态下的mark word + 偏向锁是指一段同步代码一直被一同个线程所访问，那么该线程会自动获取锁，降低获取锁的代价 + 偏向锁在竞争不激烈的情况下，效率非常高。 + 线程ID epoch unused age biased_lock lock + 54 -> 2 -> 1 -> 4 -> 1 -> 01 + + 轻量级锁状态下的mark word + 当有两个线程开始竞争这个锁对象，锁会升级为轻量级锁，两个线程公平竞争，哪个线程先占有锁对象，Mark Word 就指向哪个线程的栈帧中的锁记录 + 锁记录指针 lock + 62 -> 00 + + 重量级锁状态的mark word + 重量级锁会让其他申请的线程之间进入阻塞，性能降低。 + 重量级锁也就叫做同步锁，这个锁 对象 Mark Word 再次发生变化，会指向一个监视器（Monitor）对象，该监视器对象用集合的形 式，来登记和管理排队的线程。 + monitor对象指针 lock + 62 -> 10 + +## synchronized 的锁优化 + + JDK1.6开始的减少获得锁和释放锁带来的性能消耗，引入了“偏向锁”和“轻量级锁”。 + 需要注意的是锁可以升级但不能降级 + +## 关于 Object 和 Thread + + Object 类 有native 的 wait方法 + 调用wait 前, obtain monitor， + 调用wait 后，释放对象锁，然后当前线程进入等待状态wait set 队列中 + + sleep() 不释放锁，sleep 可以在没有锁的情况下调用， + +--- + +## 6. 12.1Java内存模型和线程 + +bid: `2022050920343900000000000005` + +### 概述 +--- +衡量一个服务性能好坏的，每秒事务处理数（Transactions Per second，TPS ），是重要指标之一。 +### 硬件的效率和一致性 +--- + 由于计算机的存储效率和计算效率的相差甚大，计算机不得不引入读写速度接近于处理器运算速度的高速缓存（cache），来作为内存和cpu直接的缓冲，但也增加了计算机系统的复杂性，尤其在多核处理器时代，每个处理器都有自己的缓存，而他们又共享同一块内存，这样就导致了一个新的问题：内存一致性。 + 为了解决内存一致性，各个处理器访问缓存时都遵循一些协议，比如MSI，MESI等，而java虚拟机同样有自己的内存模型，并且和上述介绍的硬件和缓存访问操作具有高度的类比性。 + 除了增加高速缓存之外，为了使处理器的运算单元尽量的被充分利用，处理器可能对输入的代码进行乱序执行优化，，处理器会在计算后将乱序执行的结果重组，保证最终结果一致性。 +而与处理器的乱序执行优化类似，Java虚拟机的即时编译器中也有指令重排序（Instruction Recorder）优化。 +### Java 内存模型 +--- +主内存和工作内存。 +首先要明确一点，很容易混淆的是，虚拟机栈是一个jvm运行时的存储结构，并不是运算。 +从更基础的层次来说，主内存直接对应物理硬件的内存，工作内存对应于寄存器和高速缓存。 +而工作内存直接存储了被该线程使用的变量的主内存副本，这里的副本，有可能是对象的引用或者，对象的某个字段，但不会有虚拟机把整个java对象复制一次的。 +### 内存间的交互操作 +--- +Java内存模型规定了一些操作来实现内存间交互，JVM会保证它们是原子的 +lock： +锁定，把变量标识为线程独占，作用于主内存变量 +unlock： +解锁，把锁定的变量释放，别的线程才能使用，作用于主内存变量 +read： +读取，把变量从主内存读取到工作内存 +load： +载入，把read读取到的值放入工作内存的变量副本中 +use： +使用，把工作内存中的一个变量的值传递给执行引擎 +assign： +复制，把从执行引擎接收到的值赋给工作内存里面的变量 +store： +存储，把工作内存中一个变量的值传递到主内存中 +write： +写入，把store进来的数据存放到主内存的变量中 + +注意，Java内存模型，只要求上述两个操作必须按顺序执行，但没有要求连续执行。也就是说read和load之间store与write之间是可以插入其他的指令的。比如对主内存中a，b变量进行访问时，可能出现，read a，read b，load b，load a。 +后来java设计团队，对java内存模型进行了简化，read，write，lock，unlock四种 + +--- + +## 7. 12.2关键字volatile + +bid: `2022050921201400000000000006` + +关键字volatile是java虚拟机提供的最轻量级的同步机制。 +当一个变量被定义为volatile时，它具备两种特性。 +第一种是**可见性**。 +即每次get时，强制刷新。 +一个误解区，字节码就是原子操作，这是不对的，一个字节码指令在解释执行时，如果是编译执行，一条字节码会有可能被转化为若干个本地机器指令。此处，用-XX：+PrintAssembly参数输出反汇编来分析。 + +第二种是，**有序性**。 +即，禁止指令重排序（Instruction Recorder）优化。 +被volatile修饰的变量，赋值后会多执行一个"lock addl"操作，这个操作相当于一个memory barrier（内存屏障），指令重拍时，不能把后面的指令排序到内存屏障前面去，只有一个处理器访问时，不需要内存屏障。 +addl 是一个空操作，（把ESP寄存器的值 + 0），这个操作相当于把缓存中的变量做了一次store和write操作。 +lock iddl指令把修改同步到内存时，意味着所有的之前的操作都已完成，便形成了指令重排序无法穿越内存屏障的效果。 +针对于long和double的类型变量，不通虚拟机是有着不同的实现，此处不做描述。 + +--- + +## 8. 12.3 原子性，可见性，有序性 + +bid: `2022050921544800000000000007` + +Java内存模型，是围绕着在并发过程中如何处理原子性，可见性，和有序性的这三个特点建立的。 +### 原子性（Atomicity） +--- +由Java内存模型直接保证的原子性操作有，read，load，assign，use，store，write这6个，我们大致可以认为，对基本类型的访问读写都是原子性的（long double类外）。 +尽管，虚拟机没有把lock和unlock操作直接开放给用户，但是却提供了更高层次的字节码指令monitorenter和monitorexit来隐式地这两个操作，反映到同步块就是synchronized关键字，因此synchronzed块之间的操作也属于原子操作。 +### 可见性 （Visibility） +--- +可见性，即变量的修改对其他线程是可见的，无论是普通变量还是volatile变量都是会将结果刷新到主内存的，只是volatile是其他线程获取该变量时强制刷新到主内存，而普通变量并没有。 +除此之外，java还有两个关键字能够实现可见性，即synchronized和final +synchronized的可见性是因为"对一个变量unlock操作之前，必须先把此变量同步回到主内存中（即执行了store，write操作）"的这条规则获得的。 +而final的可见性是指，被final修饰的字段在构造器中一旦完成了初始化，并且构造器并没有把这个引用传递出去，那么其他线程就能看见final字段。 +### 有序性 （Ordering） +--- +Java语言提供了volatile和synchronized两个关键字来保证线程之间的操作是有序性的。 +volatile本身就是禁止了指令重排序。 +而synchronized是由"一个变量在同一时刻只允许有一条线程对其进行lock操作" + +synchronzed能保证以上三个特性，但是并发场景会影响性能。 + +--- + +## 9. 12.4 Happens-Before + +bid: `2022050922310000000000000008` + +### 先行发生原则（Happens-Before） +Java内存模型中如果所有的有序性都仅靠volatile和synchronized来完成的话，会有很多操作变得啰嗦。 +Java语言有一个先行发生原则（Happens-Before）。 +规则： +1.程序次序规则 +2.Monitor Lock Rule +3.volatile Variable Rule +4.Thread Start Rule，start方法最先执行 +5.Thread Termination Rule，所有方法都优先于 +6.线程中断规则。 +7.对象终结规则，一个对象初始化完成先行发生于finalize（）方法。 +8.传递性，A》B，B》C，那么A》C +jintian +1111 + +--- diff --git a/AI/mechine learning/计算机网路.md b/AI/mechine learning/计算机网路.md new file mode 100644 index 0000000..070c466 --- /dev/null +++ b/AI/mechine learning/计算机网路.md @@ -0,0 +1,475 @@ +# 计算机网路 + +> 来源：原 mongodb 集合 `t_blog` · 整理日期：2026-08-25 +> 分类 ID：`2022050410146100000000000003` · 排序：7 · 文章数：5 + +## 目录 + +1. [curl 详解](#curl-详解) +2. [Route](#route) +3. [Tptables概念](#tptables概念) +4. [iptables 规则和ACTION](#iptables-规则和action) +5. [协议](#协议) + +--- + +## 1. curl 详解 + +bid: `2023031518364800000000000023` + +### Header + +使用 -H 来传递参数 + + curl -H "tenantId=321" -H "authorization=xxxx:XXxx" + +### Method + +使用 -X 来指定方法 + + curl -X GET + +### URL + +对url 进行添加双引号 + + curl "www.baidu.com" + +### example + +#### 1. Get + curl -H "authorization:X:XX" -H "tenantid:sssss" -X GET "localhost:8080/violin-api/api/v1/reminder?reminder_id=xxxxxx" + +#### 2. Post + + curl -H "Content-Type: application/json" -H "authorization:X:XX" -H "tenantid:sssss" -X POST -d '{"title":"xxxxx","info":"xxxxxxxxxxxxx"}' "localhost:8080/violin-api/api/v1/reminder" + +### 使用注意 + +- powershell 中的curl 只是个alise 不适用 +- window下的curl 会出现编码问题，尤其"并不会编码 会导致 后台 出现下列错误 + + {"error":"invalid character '\\'' looking for beginning of value"} + +--- + +## 2. Route + +bid: `2023032623183000000000000024` + +### 路由表 +--- +`ip route` + + ip route 其实是没有体现网关存在。描述的是网卡和目的ip，源ip之间的关系 + 默认 经过 10.0.8.1 走默认网卡eth0 + 意思是说，下面路由要是匹配不到的话，就是经过10.0.8.1 网关（网卡设备eth0） + 去 10.0.8.0/22 也走 eth0 网卡，但是源ip是10.0.8.13 + 如果是去172.17.0.0/16 走 docker0网卡，源ip是172.17.0.1 + [root@node2 dev]# ip route + default via 10.0.8.1 dev eth0 + 10.0.8.0/22 dev eth0 proto kernel scope link src 10.0.8.13 + 169.254.0.0/16 dev eth0 scope link metric 1002 + 172.17.0.0/16 dev docker0 proto kernel scope link src 172.17.0.1 + + +`route -n` + + route -n 更多的体现着ip地址的设置问题， + 直接可以看到默认的网关gateway是10.0.8.1，通过子网掩码，确定网络地址，访问10.0.8.0的网关是0.0.0.0 即，内部网络，不走网关。 + [root@node2 dev]# route -n + Kernel IP routing table + Destination Gateway Genmask Flags Metric Ref Use Iface + 0.0.0.0 10.0.8.1 0.0.0.0 UG 0 0 0 eth0 + 10.0.8.0 0.0.0.0 255.255.252.0 U 0 0 0 eth0 + 169.254.0.0 0.0.0.0 255.255.0.0 U 1002 0 0 eth0 + 172.17.0.0 0.0.0.0 255.255.0.0 U 0 0 0 docker0 + +`ip addr` + + inet表示主机地址和所处网络段。 + 2: eth0: mtu 1500 qdisc mq state UP group default qlen 1000 + link/ether 52:54:00:39:ea:c4 brd ff:ff:ff:ff:ff:ff + inet 10.0.8.13/22 brd 10.0.11.255 scope global eth0 + valid_lft forever preferred_lft forever + inet6 fe80::5054:ff:fe39:eac4/64 scope link + valid_lft forever preferred_lft forever + +`Flags 标记` + + U（route is up）该路由是启动的 + H（target is a host）目标是一台主机（ip） + G（use gateway）需要通过外部的主机传送数据包 + R（reinstate route for dynamic routing）使用动态路由时恢复路由标记 + D（dynamically installed by daemon or redirect） + 已经由服务器或转port功能设置为动态路由! + (reject route)这个路由将不会被接受（用来组织不安全的网段） + 注：显示路由信息从上到下是从范围大到小。 + +`ip neigh` + + 10.0.8.1 这个ip地址对象的网卡是eth0还有mac，但网卡本省绑定的ip地址10.0.8.3，又和ip addr中 link src 10.0.8.3 一样。 + 这样就说明了一个问题，同一网段的访问，是不通过网关直接走网卡，不同网段，需要走10.0.8.1 + [root@node3 ~]# ip neigh + 10.0.8.1 dev eth0 lladdr fe:ee:30:30:20:26 REACHABLE + +`gateway：指的是路由通过哪个gateway出去` +`Gateway是0.0.0.0或者*表示目标是本主机所属的网络,不需要路由` + + + +### take in actions +--- + +--- + +## 3. Tptables概念 + +bid: `2023032623302100000000000025` + +### Tptables概念 +--- +[新手教学](https://www.zsythink.net/archives/1199) +iptables is a package filter firewall for linux system. + +iptables cad do below： +- filter package （封包过滤） +- package redirect （封包重定向） +- network address translation （网络地址转换） + +to learn iptables， you should to understand the concepts of below： +#### 1. rules +--- + - match ：符合指定的条件，比如指定的 IP 地址和端口。 + - drop ：当一个包到达时，简单地丢弃，不做其它任何处理。 + - accept：和丢弃相反，接受这个包，让这个包通过。 + - reject：和丢弃相似，但它还会向发送这个包的源主机发送错误消息。这个错误消息可以指定，也可以自动产生 + - target：指定的动作，说明如何处理一个包，比如：丢弃，接受，或拒绝。 + - jump：指定的动作，说明如何处理一个包，比如：丢弃，接受，或拒绝。 + - rule：一个或多个匹配及其对应的目标。 + +#### 2. iptables和netfilter的关系 +--- +iptables只是Linux防火墙的管理工具而已，位于/sbin/iptables +真正实现防火墙功能的是 netfilter，它是Linux内核中实现包过滤的内部结构。 + +#### 3. iptables的规则表和链 +--- +- 表（tables）： +iptables内置了4个表，即filter表、nat表、mangle表和raw表。 +分别用于实现包过滤，网络地址转换、包重构(修改)和数据跟踪处理。 + +- 链（chains）： +一个有顺序的check list，每一条链中可以有一条或数条规则。 +如果满足，系统就会根据该条规则所定义的方法处理该数据包； +否则iptables将继续检查下一条规则，如果该数据包不符合链中任一条规则，iptables就会根据该链预先定义的默认策略来处理数据包。 + +- 规则表： + 1）filter表——三个链：INPUT、FORWARD、OUTPUT +作用：过滤数据包 内核模块：iptables_filter. + 2）Nat表——三个链：PREROUTING、POSTROUTING、OUTPUT +作用：用于网络地址转换（IP、端口） 内核模块：iptable_nat + 3）Mangle表——五个链：PREROUTING、POSTROUTING、INPUT、OUTPUT、FORWARD +作用：修改数据包的服务类型、TTL、并且可以配置路由实现QOS内核模块：iptable_mangle(别看这个表这么麻烦，咱们设置策略时几乎都不会用到它) + 4）Raw表——两个链：OUTPUT、PREROUTING +作用：决定数据包是否被状态跟踪机制处理 内核模块：iptable_raw + +- 规则链： + 1）INPUT——进来的数据包应用此规则链中的策略 + 2）OUTPUT——外出的数据包应用此规则链中的策略 + 3）FORWARD——转发数据包时应用此规则链中的策略 + 4）PREROUTING——对数据包作路由选择前应用此链中的规则 +（记住！所有的数据包进来的时侯都先由这个链处理） + 5）POSTROUTING——对数据包作路由选择后应用此链中的规则 +（所有的数据包出来的时侯都先由这个链处理） +--- +### command +[参照](http://t.zoukankan.com/sixloop-p-iptables-save-help.html) +[命令参照](https://zhuanlan.zhihu.com/p/160840906) + + +iptables --help 也能看到,先列出一些常用的. + + -A --append + Append to chain + -m --match match + extended match (may load extension) + -s --source address[/mask][...] + source specification + -d --destination -d address[/mask][...] + destination specification + -j --jump -j target + target for rule (may load target extension) + -p --protocol -p proto + protocol: by number or name, eg. 'tcp' + -N --new -N chain + Create a new user-defined chain + -t --table -t table + table to manipulate (default: `filter') + -i --in-interface -i [!] input name[+] + network interface name ([+] for wildcard) + -o --out-interface -o [!] output name[+] + network interface name ([+] for wildcard) +### 一些memo +--- +[新手教学](https://www.zsythink.net/archives/1199) + +1. 通常我们只关系nat表和filter表 +`raw -> mangle -> nat -> filter` +2. 创建 chain 时候，如果不指定-t table，默认是filter表 +3. ！ 表示 取非 +`-p ! tcp 表示不是tcp的` +4. iptables -h 中的[!]表示支持 非 规则 +`[!] --protocol -p proto protocol: by number or name, eg. tcp` +5. -i -o 是匹配网卡 +6. iptables -m comment 模块 +`iptables -m comment --comment "xxx"` +就是对该chain进行解释。其中comment是扩展模块，常见的模块有addrtype 模块了。 +`iptables -m addrtype --dst-type LOCAL -j DOCKER` +`iptables -m addrtype --help 可以看更详细解说` +addrtype表示对报文的地址类型进行匹配，-dst-type 表示destination +LOCAL:表示地址是本地地址，指本地一切地址含：127.0.0.1回环地址 + +7. -j DNAT 和 -j SNAT +8. + +--- + +## 4. iptables 规则和ACTION + +bid: `2023032623358600000000000026` + +### 规则查询 +--- +`iptables -t filter -L` +`iptables -nvL INPUT` + + [root@node3 ~]# iptables -nvL INPUT + # policy 表示默认规则 + Chain INPUT (policy ACCEPT 344K packets, 31M bytes) + pkts bytes target prot opt in out source destination + 0 0 in_test tcp -- * * 0.0.0.0/0 0.0.0.0/0 tcp dpt:8000 + 1741K 187M KUBE-FIREWALL all -- * * 0.0.0.0/0 0.0.0.0/0 + +### 规则管理 +--- +`iptables -F INPUT` + + # 清空filter表的INPUT链 + iptables -F INPUT + + # 添加拒绝INPUT规则 + # -I 表示链首插入规则，-A 表示链尾添加规则 + # 来自49.233.4.79 的 丢弃 + iptables -t filter -I INPUT -s 49.233.4.79 -j DROP + # 所以就算添加了下面的ACCEPT规则，也是ping不同的，因为在链首已经被丢弃 + iptables -t filter -A INPUT -s 49.233.4.79 -j ACCEPT + # 如果我再把这个规则添加到链首，就可以ping通了。 + iptables -t filter -I INPUT -s 49.233.4.79 -j ACCEPT + + [root@node3 ~]# iptables -nvL INPUT + Chain INPUT (policy ACCEPT 451 packets, 45257 bytes) + pkts bytes target prot opt in out source destination + 2 168 ACCEPT all -- * * 49.233.4.79 0.0.0.0/0 + 5 420 DROP all -- * * 49.233.4.79 0.0.0.0/0 + 0 0 ACCEPT all -- * * 49.233.4.79 0.0.0.0/0 + +### 删除规则 +--- + + # 指定编号删除 -D INPUT 3 ，删除INPUT 链中，编号为3的规则 + # 先查看规则编号 使用--line + iptables -nvL INPUT --line + iptables -t filter -D INPUT 3 + + # 根据匹配条件删除 + iptables -t filter -D INPUT -s 49.233.4.79 -j ACCEPT + + # 整体删除 + iptables -t filter -F + +### 修改规则 +--- + + # 使用-R 指定链，使用数字 来指定 具有相同数字编号的规则 + iptables -t filter -R INPUT 1 -s 49.233.4.79 -j REJECT + + # 可以看到 REJECT是拒绝行为 + [root@node1 tomcat]# ping 43.138.73.106 + PING 43.138.73.106 (43.138.73.106) 56(84) bytes of data. + From 43.138.73.106 icmp_seq=1 Destination Port Unreachable + From 43.138.73.106 icmp_seq=2 Destination Port Unreachable +### 保存规则 +--- + + service iptables save + +### 匹配规则 +--- +1. 如果匹配不到任何规则，那么就匹配默认规则（policy）。 + + # 小误区，关于！ 的用法理解， + iptable -t filter -F + # 不是 49.233.4.79 的都接受，但是并没有说是49.233.4.79的拒绝 + # 只是说49.233.4.79的没有匹配到这个规则，因为INPUT 默认都是 ACCEPT + # 所以，49.233.4.79的也会通过 + iptables -t filter -A INPUT 1 -s ！49.233.4.79 -j ACCEPT + # -s -d 如果不指定，即0.0.0.0/0 即所有ip + # 多个条件是 and 关系，必须都符合 +2. 匹配条件：协议类型 + + # 使用-p选项，指定需要匹配的报文的协议类型 + # 比如我们拒绝tcp协议 + iptables -t filter -F + iptables -t filter -I INPUT -s 49.233.4.79 -p tcp -j REJECT + # 这样我们ping 是可以ping通的，因为ping是icmp协议 + # 而curl 43.138.73.106 是被拒绝的，因为是http（tcp）协议 + # centos7中 支持以下协议 + # tcp, udp, udplite, icmp, icmpv6,esp, ah, sctp, mh + # 不指定协议，即 -p all 任意匹配 + +3. 匹配条件：网卡接口 + + # -i -o + # -i 表示来自哪个网卡 + # PREROUTING 和 INPUT FORWARD 使用 + # -o 表示要去哪个网卡 + # POSTROUTING 和 OUTPUT FORWARD 使用 +4. -m match 扩展匹配 + + # 如果想要使用扩展匹配条件，则需要依赖一些扩展模块 + # 即扩展匹配，需要使用-m来指定模块 + iptables -A INPUT -s 49.233.4.79 -p tcp -m tcp --dport 80 -j REJECT + [root@node3 ~]# iptables -nvL INPUT --line + Chain INPUT (policy ACCEPT 14 packets, 964 bytes) + num pkts bytes target prot opt in out source destination + 1 2 120 REJECT tcp -- * * 49.233.4.79 0.0.0.0/0 reject-with icmp-port-unreachable + 2 0 0 REJECT tcp -- * * 49.233.4.79 0.0.0.0/0 tcp dpt:80 reject-with icmp-port-unreachable + # 可以看出 上面是使用-m tcp 使用tcp扩展模块 + # 如果-p tcp 和 -m tcp 是一样的时候，-m tcp是可以省略的 + # --sport 表示源端口号 + # –dport 22:25 表示22，23，24，25 范围 + # ：22 和 80： 表示 0：22 80：65535 + # 多个离散端口使用 multiport 模块 + -m multiport –dports 22,36,80 + +5. -m iprange 扩展模块 + + 使用iprange扩展模块可以指定”一段连续的IP地址范围”，用于匹配报文的源地址或者目标地址 + # --src-range --dst-range + -m iprange --src-range 192.168.1.127-192.168.1.146 + +6. -m conntrack 扩展模块 + + conntrack 状态跟踪 + conntrack共可以为连接标记五种状态： + NEW，ESTABLISHED，RELATED，INVALID，UNTRACKED + + +### 自定义链 +--- + + 自定义链并不能直接使用，而是需要被默认链引用才能够使 + # 自定义链IN-WEB + iptables -F INPUT + iptables -N IN-WEB + # 可以看到，自定义链没有被任何默认的链引用，即无效状态。 + Chain IN-WEB (0 references) + pkts bytes target prot opt in out source destination + + 删除 -X 自定义链，但是删除前必须要清空链上的规则 + iptables -F IN-WEB + iptables -X IN-WEB + +### ACTION +--- + 我们知道-j target ，target既可以接ACTION，也可以接Chain + 我们已知的ACTION有 ACCEPT，DROP，REJECT + + `ACCPET` + + ACCEPT 将封包放行，进行完此处理动作后，将不再比对其它规则，直接跳往下一个规则炼。 + `MARK` + + MARK 将封包标上某个代号，以便提供作为后续过滤的条件判断依据，进行完此处理动作后，将会继续比对其它规则 + `RETURN` + + 结束在目前规则炼中的过滤程序，返回主规则炼继续过滤. + 如果把自定义规则炼看成是一个子程序，那么这个动作，就相当于提早结束子程序并返回到主程序中。 + `SNAT` + + 改写封包来源 IP 为某特定 IP 或 IP 范围，可以指定 port 对应的范围，进行完此处理动作后 + 将直接跳往下一个规则炼（mangle:postrouting）。范例如下： + iptables -t nat -A POSTROUTING -p tcp -o eth0 -j SNAT --to-source 194.236.50.155-194.236.50.160:1024-32000 + `DNAT` + + DNAT 改写封包目的地 IP 为某特定 IP 或 IP 范围，可以指定 port 对应的范围，进行完此处理动作后， + 将会直接跳往下一个规则炼（filter:input 或 filter:forward）。范例如下： + iptables -t nat -A PREROUTING -p tcp -d 15.45.23.67 --dport 80 -j DNAT --to-destination 192.168.1.1-192.168.1.10:80-100 + `REJECT` + + 拦阻该封包，并传送封包通知对方 + + `DROP` + + 丢弃封包不予处理，进行完此处理动作后，将不再比对其它规则，直接中断过滤程序 + + `REDIRECT` + + ... + `MASQUERADE` + + ... + + + `NAT这个概念：` + + NAT是Network Address Translation的缩写，译为”网络地址转换”，NAT说白了就是修改报文的IP地址 + -j SNAT --to-source xxx.xxx.xxx.x + -j DNAT --to-destination xxx.xx + +### 关于链的顺序 +--- + +- nat 表中的规则可以被哪些链使用：PREROUTING，OUTPUT，POSTROUTING（centos7中还有INPUT，centos6中没有） + +- filter 表中的规则可以被哪些链使用：INPUT，FORWARD，OUTPUT + + raw 和 mangle不去考虑的话 + 表的顺序是 nat -> filter + 1. 当一个数据包进入网卡时，它首先进入PREROUTING链 + nat -> PREROUTING + + 2.1 如果数据包就是进入本机的 + nat -> INPUT + filter -> INPUT + nat -> OUTPUT + filter -> OUTPUT + + 2.2 如果数据包是需要转发的 + filter -> FORWARD + + 3. 最后进入POSTROUTING + nat -> POSTROUTING + +1 +2 + +--- + +## 5. 协议 + +bid: `2023032623438200000000000027` + +## 协议 +传输层TCP - +网路层协议IP - 报文 +数据链路层协议MAC - 帧 +--- +### ARP协议 +--- +[ARP](https://blog.csdn.net/weixin_39761696/article/details/110578444) +ADDRESS Resolution protocol 是一个通过第三层IP地址，找到第二层MAC的协议。 +OSI模型把网络运营分成七层，IP地址在OSI模型的第三层，MAC地址在第二层，彼此之间不立即相处。在根据以太网接口推送IP数据时，必须先封装形式第三层（32位IP地址）、再封装第二层（48位MAC地址）的报头，但因为推送时只了解总体目标IP地址，不清楚其MAC地址，又不可以跨第二、三层，因此必须应用地址解析协义。 + +---