单线程Reactor模型

news2024/11/20 10:39:22

单线程Reactor模型

Reactor模型只是对select\poll\epoll等网络模型的封装，本文讲解基于epoll实现Reactor模型

Reactor模型

单线程Reactor模型较为简单，如图：

20230107161748

服务器接收多个client连接请求后，统一交由Reactor处理，其中，新连接请求与数据交互分开处理：

当服务器到达一个新连接后 => 交给Acceptor处理，调用accept()取出连接文件描述符connfd =>为这个connfd绑定回调函数，加入Handler => Handler将connfd及其回调函数加入epoll => epoll检测到这个connfd有事件发生时，调用其回调函数

设计实现

Reactor主要由两部分组成

  1. fd和其绑定的回调函数
  2. 监听fd，调用其对应的回调函数

其实epoll中,data.ptr本身就可以指向一个callback，在这种情况下，就可以视为一种reactor模式了；但是对于select和poll，本身不能进行fd与callback的绑定，需要在用户态记录fd和callback的映射关系

由于本文的重点是Reactor模型，而且记录fd和callback的映射关系有很多的方便之处（如fd读写事件的切换，底层网络模型的更换等），其实现设计图如下：

20230107172649

Reactor组成：

  1. evblk：记录fd和回调函数的映射
    • 事件数组：长度1024，索引为fd，值为ntyevent
    • 块链表：当fd数量较多时，就需要新申请事件数组和块链表节点，挂到块链表上
    • 由于进程内fd顺序增长，所以块链表节点采用尾插法（块链表也可以换成数组或deque）
  2. epfd：创建一个epoll，监听事件
    • 将evblk中的数组元素加入epoll

API

  1. 回调函数
    • recv_cb()：fd指定可读事件时，绑定到connfd
    • send_cb()：fd指定可写事件时，绑定到connfd
    • accept_cb()：fd指定可读事件时，绑定到listenfd（全连接队列非空）
  2. reactor
    • ntyreactor_init()：创建epoll，reactor结构体初始化
    • ntyreactor_alloc()：分配事件数组和对应的块节点，插入到evblk中
    • ntyreactor_idx()：evblk索引函数
    • ntyreactor_destory()：销毁reactor
  3. 事件
    • nty_event_set()：设置事件数组元素值，也就是为fd绑定回调函数
    • nty_event_add()：将事件加入epoll以被监听
    • ntyreactor_addlistener()：调用nty_event_set()和nty_event_add()，主要用于socket初始化后，为listenfd绑定accept_cb函数
    • ntyreactor_run：对于就绪的事件，执行对应的回调函数

代码实现

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <arpa/inet.h>

#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <time.h>


#define BUFFER_LENGTH		4096
#define MAX_EPOLL_EVENTS	1024
#define SERVER_PORT			8888
#define PORT_COUNT			100

typedef int NCALLBACK(int ,int, void*);

struct ntyevent {
	int fd;
	int events;    //对应的监听事件，EPOLLIN和EPOLLOUT（不同的事件，走不同的回调函数）
	void *arg;    // reactor指针
	int (*callback)(int fd, int events, void *arg);
	int status;         // epoll是否监听
	char buffer[BUFFER_LENGTH];  // 读写buff也可分别设置
	int length;      // 实际从buff读取写入的数据长度
	long last_active;
};

struct eventblock {   // 块节点
	struct eventblock *next;
	struct ntyevent *events;
};

struct ntyreactor {   
	int epfd;
	int blkcnt;    // 块节点的数量
	struct eventblock *evblk; // 存100w个连接 数组（fd定死了），deque等，这里采用链表
};

int recv_cb(int fd, int events, void *arg);
int send_cb(int fd, int events, void *arg);
struct ntyevent *ntyreactor_idx(struct ntyreactor *reactor, int sockfd);

// 设置reactor中的ntyevent节点
void nty_event_set(struct ntyevent *ev, int fd, NCALLBACK callback, void *arg) {
	ev->fd = fd;
	ev->callback = callback;
	ev->events = 0;
	ev->arg = arg;
	ev->last_active = time(NULL);
	return ;
}

// ntyevent节点加入reactor后,还需加入epoll监听
int nty_event_add(int epfd, int events, struct ntyevent *ev) {

	struct epoll_event ep_ev = {0, {0}};
	ep_ev.data.ptr = ev;
	ep_ev.events = ev->events = events;

	int op;
	if (ev->status == 1) {
		op = EPOLL_CTL_MOD;
	} else {
		op = EPOLL_CTL_ADD;
		ev->status = 1;
	}

	if (epoll_ctl(epfd, op, ev->fd, &ep_ev) < 0) {
		printf("event add failed [fd=%d], events[%d]\n", ev->fd, events);
		return -1;
	}

	return 0;
}

// 从epoll中删除该fd，不再监听
int nty_event_del(int epfd, struct ntyevent *ev) {

	struct epoll_event ep_ev = {0, {0}};
	if (ev->status != 1) {
		return -1;
	}

	ep_ev.data.ptr = ev;
	ev->status = 0;
	epoll_ctl(epfd, EPOLL_CTL_DEL, ev->fd, &ep_ev);

	return 0;
}
// fd从监听读事件，变成监听写事件
int recv_cb(int fd, int events, void *arg) {

	struct ntyreactor *reactor = (struct ntyreactor*)arg;
	struct ntyevent *ev = ntyreactor_idx(reactor, fd);

	int len = recv(fd, ev->buffer, BUFFER_LENGTH , 0); // 读读缓冲区
	nty_event_del(reactor->epfd, ev);   // 将该fd从epoll中删除，该fd需改成写事件加入epoll

	if (len > 0) {
		ev->length = len;
		ev->buffer[len] = '\0';
		printf("C[%d]:%s\n", fd, ev->buffer);
		nty_event_set(ev, fd, send_cb, reactor);
		nty_event_add(reactor->epfd, EPOLLOUT, ev);
	} else if (len == 0) {
		close(ev->fd);
		//printf("[fd=%d] pos[%ld], closed\n", fd, ev-reactor->events);
		 
	} else {
		close(ev->fd);
		printf("recv[fd=%d] error[%d]:%s\n", fd, errno, strerror(errno));
		
	}

	return len;
}
// fd从监听写事件，变成监听读事件
int send_cb(int fd, int events, void *arg) {

	struct ntyreactor *reactor = (struct ntyreactor*)arg;
	struct ntyevent *ev = ntyreactor_idx(reactor, fd);

	int len = send(fd, ev->buffer, ev->length, 0);
	if (len > 0) {
		printf("send[fd=%d], [%d]%s\n", fd, len, ev->buffer);
		nty_event_del(reactor->epfd, ev);
		nty_event_set(ev, fd, recv_cb, reactor);
		nty_event_add(reactor->epfd, EPOLLIN, ev);
		
	} else {

		close(ev->fd);

		nty_event_del(reactor->epfd, ev);
		printf("send[fd=%d] error %s\n", fd, strerror(errno));

	}

	return len;
}
// listenfd监听新连接加入epoll
int accept_cb(int fd, int events, void *arg) {

	struct ntyreactor *reactor = (struct ntyreactor*)arg;
	if (reactor == NULL) return -1;

	struct sockaddr_in client_addr;
	socklen_t len = sizeof(client_addr);

	int clientfd;

	if ((clientfd = accept(fd, (struct sockaddr*)&client_addr, &len)) == -1) {
		if (errno != EAGAIN && errno != EINTR) {
			
		}
		printf("accept: %s\n", strerror(errno));
		return -1;
	}

	int flag = 0;
	if ((flag = fcntl(clientfd, F_SETFL, O_NONBLOCK)) < 0) {
		printf("%s: fcntl nonblocking failed, %d\n", __func__, MAX_EPOLL_EVENTS);
		return -1;
	}

	struct ntyevent *event = ntyreactor_idx(reactor, clientfd);
	
	nty_event_set(event, clientfd, recv_cb, reactor);
	nty_event_add(reactor->epfd, EPOLLIN, event);

	printf("new connect [%s:%d], pos[%d]\n", 
	    inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port), clientfd);

	return 0;

}
// 初始化socket连接
int init_sock(short port) {

	int fd = socket(AF_INET, SOCK_STREAM, 0);
	fcntl(fd, F_SETFL, O_NONBLOCK);

	struct sockaddr_in server_addr;
	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	server_addr.sin_port = htons(port);

	bind(fd, (struct sockaddr*)&server_addr, sizeof(server_addr));

	if (listen(fd, 20) < 0) {   // 20：Linux中全连接队列中连接的数量
		printf("listen failed : %s\n", strerror(errno));
	}
	return fd;
}

// 分配一个块节点和数组，尾插到reactor中
int ntyreactor_alloc(struct ntyreactor *reactor) {

	if (reactor == NULL) return -1;
	if (reactor->evblk == NULL) return -1;
    // 尾插，fd在进程内是顺序的
	struct eventblock *blk = reactor->evblk;
	while (blk->next != NULL) {
		blk = blk->next;
	}
    // 先分配数组，因为内存越大，越容易分配失败
	struct ntyevent *evs = (struct ntyevent*)malloc((MAX_EPOLL_EVENTS) * sizeof(struct ntyevent));
	if (evs == NULL) {
		printf("ntyreactor_alloc ntyevents failed\n");
		return -2;
	}
	memset(evs, 0, (MAX_EPOLL_EVENTS) * sizeof(struct ntyevent));
    // 分配节点
	struct eventblock *block = (struct eventblock *)malloc(sizeof(struct eventblock));
	if (block == NULL) {
		printf("ntyreactor_alloc eventblock failed\n");
		return -2;
	}
	memset(block, 0, sizeof(struct eventblock));
    // 加入reactor
	block->events = evs;
	block->next = NULL;
	blk->next = block;
	reactor->blkcnt ++;
	return 0;
}
// 索引函数，返回fd对应的event 
struct ntyevent *ntyreactor_idx(struct ntyreactor *reactor, int sockfd) {

	int blkidx = sockfd / MAX_EPOLL_EVENTS;
    // 防止索引越界
    // 其实小索引也可能越界：比如我第二个数组中的fd全部处理完了，那就该释放了（这里没释放），再来一个1024就找不到对应的事件了
	while (blkidx >= reactor->blkcnt) {
		ntyreactor_alloc(reactor);
	}

	int i = 0;
	struct eventblock *blk = reactor->evblk;
	while(i ++ < blkidx && blk != NULL) {
		blk = blk->next;
	}

	return &blk->events[sockfd % MAX_EPOLL_EVENTS];
}
// 初始化reactor结构体
int ntyreactor_init(struct ntyreactor *reactor) {

	if (reactor == NULL) return -1;    // reactor内存清零
	memset(reactor, 0, sizeof(struct ntyreactor));

	reactor->epfd = epoll_create(1);  // epoll初始化
	if (reactor->epfd <= 0) {
		printf("create epfd in %s err %s\n", __func__, strerror(errno));
		return -2;
	}
    // 数组初始化
	struct ntyevent *evs = (struct ntyevent*)malloc((MAX_EPOLL_EVENTS) * sizeof(struct ntyevent));
	if (evs == NULL) {
		printf("ntyreactor_alloc ntyevents failed\n");
		return -2;
	}
	memset(evs, 0, (MAX_EPOLL_EVENTS) * sizeof(struct ntyevent));
    // 块节点初始化
	struct eventblock *block = (struct eventblock *)malloc(sizeof(struct eventblock));
	if (block == NULL) {
		printf("ntyreactor_alloc eventblock failed\n");
		return -2;
	}
	memset(block, 0, sizeof(struct eventblock));

	block->events = evs;
	block->next = NULL;

	reactor->evblk = block;
	reactor->blkcnt = 1;

	return 0;
}
// 销毁reactor
int ntyreactor_destory(struct ntyreactor *reactor) {
	
    close(reactor->epfd);   // 关闭epoll

	struct eventblock *blk = reactor->evblk;
	struct eventblock *blk_next = NULL;
    // 链表的释放
	while (blk != NULL) {
		blk_next = blk->next;
		free(blk->events);
		free(blk);
		blk = blk_next;
	}
	return 0;
}
// 将事件加入到reactor和epoll
int ntyreactor_addlistener(struct ntyreactor *reactor, int sockfd, NCALLBACK *acceptor) {

	if (reactor == NULL) return -1;
	if (reactor->evblk == NULL) return -1;

	struct ntyevent *event = ntyreactor_idx(reactor, sockfd);
	nty_event_set(event, sockfd, acceptor, reactor);
	nty_event_add(reactor->epfd, EPOLLIN, event);
	return 0;
}
// 启动reactor，reactor能支持百万连接，是因为epoll本身就能支持百万连接
int ntyreactor_run(struct ntyreactor *reactor) {
	if (reactor == NULL) return -1;
	if (reactor->epfd < 0) return -1;
	if (reactor->evblk == NULL) return -1;
	
    // 就绪列表中事件的data就有这个回调函数啊
    // 而且下面也是直接取的data中的回调，为啥还要reactor?
	struct epoll_event events[MAX_EPOLL_EVENTS+1];   // 就绪队列里的事件不需要取太多，多取几次就好
	
	int checkpos = 0, i;

	while (1) {
		int nready = epoll_wait(reactor->epfd, events, MAX_EPOLL_EVENTS, 1000);
		if (nready < 0) {
			printf("epoll_wait error, exit\n");
			continue;
		}

		for (i = 0;i < nready;i ++) {
            // 不需要判断事件类型，直接调回调就行
			struct ntyevent *ev = (struct ntyevent*)events[i].data.ptr;
            ev->callback(ev->fd, events[i].events, ev->arg);
		}
	}
}

// 3, 6w, 1, 100 == 
// <remoteip, remoteport, localip, localport>
int main(int argc, char *argv[]) {

	unsigned short port = SERVER_PORT; // listen 8888
	if (argc == 2) {
		port = atoi(argv[1]);
	}
	struct ntyreactor *reactor = (struct ntyreactor*)malloc(sizeof(struct ntyreactor));
	ntyreactor_init(reactor);

	int i = 0;
	int sockfds[PORT_COUNT] = {0};
	for (i = 0;i < PORT_COUNT;i ++) {    // 一个连接是5元组，服务器多开些端口才能达到百万连接
		sockfds[i] = init_sock(port+i);  // 8888到8988都在监听连接，也就是一个进程有100个listenfd
		ntyreactor_addlistener(reactor, sockfds[i], accept_cb);
	}

	ntyreactor_run(reactor);

	ntyreactor_destory(reactor);

	for (i = 0;i < PORT_COUNT;i ++) {
		close(sockfds[i]);
	}

	free(reactor);
	return 0;
}

tips

  1. 边缘触发ET/水平触发FT：
    • 场景：客户向服务器socket读缓冲区一次发送32byte，但服务器一次只读10byte
    • 边缘触发：一次事件只触发一次，也就是32bytes这次只读了10byte(只读一次)，下次客户再发32byet，也只会从上次剩下的22bytes读10byte；
    • 水平触发：一次事件会触发多次，只要fd可读或可写，会不断触发（加入到就绪队列），也就是一次事件会触发4次，32byte读取完。
    • 边缘触发：适用于小数据的处理（尽量一次可读完或写完buff的）
    • 水平触发：适用于大数据库处理（如读缓冲可能会装不下用户数据），listenfd（多次调用accept()把连接取出来，加快程序处理速度，也防止连接太多，连接队列装不下而丢失fd）。
  2. listen(fd,20):
    • 在进行三次握手时，客户端第一次握手，该fd会加入Linux半连接队列，第三次握手时，该fd会加入全连接队列（也就是accept队列）
    • 其中，20是listen允许连接的最大数量，但是在有些操作系统中，如苹果，这个20是半连接+全连接的数量，而Linux中，是全连接的数量
    • DDOS攻击：进行大量的第一次握手，导致浪费了很多fd，而单个进程创建fd是有数量限制的（limit -a查看），当达到最大限制时，就导致Linux无法再接收正常请求了
  3. socket套接字：
    • 一个ip+端口就是一个socket套接字，一个服务端socket+客户端socket就是一个连接
    • 所以一台主机中的一个进程可以初始化很多套接字（监听更多的port就是了），在服务端，listenfd由socketfd转换而来。参考链接
    • linux中一切皆fd，一切fd都有inode

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/147487.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Qt—QPainter基本图形绘制详解

Qt—QPainter基本图形绘制详解

QPainter描述1、QPainter 类在小部件和其他绘制设备上执行低级绘制。2、QPainter 提供了高度优化的功能来完成大多数图形GUI程序所需的工作。它可以画从简单的线条到复杂的形状。它还可以绘制对齐的文本和像素图。QPainter 可以对继承 QPaintDevice 类的任何对象进行操作。3、Q…
阅读更多...
【追光者】2022年终总结，又是一个开始，新的挑战。愿你历尽千帆，归来仍是少年。

【追光者】2022年终总结，又是一个开始，新的挑战。愿你历尽千帆，归来仍是少年。

本文为我原创&#xff0c;未经授权&#xff0c;禁止转载&#xff0c;本文首发于 CSND博客。 这几天&#xff0c;前前后后&#xff0c;断断续续&#xff0c;一边写博客&#xff0c;一边学习&#xff0c;一边回顾我的2022&#xff0c;打磨了好几天&#xff0c;尽管还是有好多想说…
阅读更多...
指针进阶之函数指针和函数指针数组

指针进阶之函数指针和函数指针数组

文章目录一、函数指针1.简单介绍2.回忆函数3.函数地址4.函数指针5.案例&#xff08;1&#xff09;案例一&#xff08;2&#xff09;案例二&#xff08;3&#xff09;案例三&#xff08;4&#xff09;案例四代码1代码2误区6.补充二、函数指针数组1.定义2.补充3.案例&#xff08;…
阅读更多...
剑指offer----C语言版----第十二天

剑指offer----C语言版----第十二天

目录 打印从1到最大的n位数 1.1 题目描述 1.2 Leetcode上的解题思路 1.3 考虑大数的问题 1.3.1 使用字符串模拟数字的加法 1.3.2 使用全排 打印从1到最大的n位数 原题链接&#xff1a;剑指 Offer 17. 打印从1到最大的n位数 - 力扣&#xff08;LeetCode&#xff09;1.1 题…
阅读更多...
算法刷题打卡第58天：删除排序链表中的重复元素

算法刷题打卡第58天：删除排序链表中的重复元素

删除排序链表中的重复元素 难度&#xff1a;简单 给定一个已排序的链表的头 head &#xff0c;删除所有重复的元素&#xff0c;使每个元素只出现一次。返回已排序的链表 。 示例 1&#xff1a; 输入&#xff1a;head [1,1,2] 输出&#xff1a;[1,2]示例 2&#xff1a; 输入…
阅读更多...
Cesiumlab对人工模型、建筑矢量面和BIM模型的处理参数设置 CesiumLab系列教程

Cesiumlab对人工模型、建筑矢量面和BIM模型的处理参数设置 CesiumLab系列教程

CesiumLab中将人工模型&#xff08;fbx、obj&#xff09;、建筑矢量面&#xff08;shp&#xff09;和BIM模型&#xff08;clm&#xff09;的处理都集中在一起&#xff0c;统一使用通用模型处理。 输入文件部分&#xff0c;加载文件在这里不在赘述&#xff0c;输入了文件后&…
阅读更多...
陪诊系统搭建，陪诊平台应当具备什么功能？

陪诊系统搭建，陪诊平台应当具备什么功能？

随着近些年来市场的变化&#xff0c;陪诊服务也在慢慢的受到人们的关注&#xff0c;自从有了陪诊系统之后&#xff0c;帮助了许许多多独立就医不便的人群&#xff0c;给了像是搞不清就诊流程的老年人、家人不方便陪伴的孕妇、残障人士&#xff0c;以及需要陪伴就医的独居人士等…
阅读更多...
上海市“专精特新”中小企业和杨浦区“专精特新”中小企业给予5万元和3万元资助

上海市“专精特新”中小企业和杨浦区“专精特新”中小企业给予5万元和3万元资助

杨浦区“专精特新”中小企业认定一、主管部门杨浦区商务委员会二、政策依据《关于印发<杨浦区“专精特新”中小企业培育工程实施办法>的通知》&#xff08;杨商务委规〔2018〕1号&#xff09;《关于组织推荐2021年度杨浦区“专精特新”中小企业申报(复核)的通知》三、扶持…
阅读更多...
【Qt】加载.ui转化的.h头文件显示窗体

【Qt】加载.ui转化的.h头文件显示窗体

【Qt】加载.ui转化的.h头文件显示窗体1、背景2、实例3、验证1、背景 将.ui文件转化为.h头文件参考如下博客&#xff1a; 【Qt】将QtDesigner生成的.ui文件转化为.h头文件 https://jn10010537.blog.csdn.net/article/details/128589666其中生成的ui_widget.h头文件内容如下&am…
阅读更多...
TensorFlow之超级参数调优

TensorFlow之超级参数调优

Keras技术框架提供工具类库&#xff0c;用于对TensorFlow程序相关的超级参数进行调优&#xff0c;为机器学习选择正确的超级参数集合的过程被称之为超级参数调优。 超级参数是指用于治理一个机器学习模型的训练过程及其拓扑结构的变量&#xff0c;这些变量在整个训练过程中保持…
阅读更多...
尚医通-项目启动过程

尚医通-项目启动过程

1.先启动Redis&#xff1a; redis-server redis.conf & 2.启动docker&#xff1a; systemctl start docker 3.进入mongo容器&#xff1a; docker exec -it mymongo /bin/bash 4.使用MongoDB客户端进行操作 mongo 5.启动nginx&#xff1a;cmd 输入命令nginx 前期使…
阅读更多...
【Kotlin】空安全 ③ ( 手动空安全管理 | 非空断言操作符 !! | 使用 if 语句判空 )

【Kotlin】空安全 ③ ( 手动空安全管理 | 非空断言操作符 !! | 使用 if 语句判空 )

文章目录一、非空断言操作符 !!二、使用 if 语句判空一、非空断言操作符 !! Kotlin 中的 可空类型 变量 , 在运行时 可以选择 不启用 安全调用 操作 , 在调用 可空类型 变量 成员 与 方法 时 , 使用 非空断言操作符 !! , 如果 可空类型 变量为 空 , 则 直接抛出 空指针异常 K…
阅读更多...
部署k8s集群

部署k8s集群

环境准备准备三台虚拟机&#xff0c;建议最小硬件配置&#xff1a;2核CPU、2G内存、20G硬盘 &#xff0c;可以访问外网&#xff0c;&#x1f4a1;ps&#xff1a;以下命令在三台虚拟机上都要执行一遍&#xff0c;直到kubeadm init设置虚拟机hostname sudo hostnamectl set-hostn…
阅读更多...
性能优化系列之『混合式开发：小程序内核及优势介绍』

性能优化系列之『混合式开发：小程序内核及优势介绍』

文章の目录一、愿景二、技术优势三、底层内核四、行业背景五、选型建议写在最后一、愿景 触手可及&#xff1a;用户扫一扫或者搜一下即可打开应用用完即走&#xff1a;不用关心是否安装太多应用 二、技术优势 H5 相比 App 开发&#xff0c;开发门槛更低优于 H5&#xff0c;接…
阅读更多...
指针进阶篇（1）

指针进阶篇（1）

目录 &#x1f914; 前言&#x1f914; 一、&#x1f60a;字符指针&#x1f60a; 二、&#x1f61c;指针数组&#x1f61c; 三、&#x1f61d;数组指针&#x1f61d; 3.1数组指针的定义 3.2&数组名VS数组名 3.3数组指针的使用 四、&#x1f31d;数组参数&#xff0c…
阅读更多...
LeetCode算法之----回溯

LeetCode算法之----回溯

目录 【一】前言 【二】全排列 【三】电话号码的字母组合 【四】括号生成 【五】组合总和 【六】子集 【七】总结 【一】前言 回溯算法采用试错的思想&#xff0c;尝试分步的来解决一个问题。在分步解决问题的过程中&#xff0c;当它通过尝试发现现有的分步答案不能得到有效的…
阅读更多...
helm、k8s dasboard、rancher、kubesphere介绍及使用

helm、k8s dasboard、rancher、kubesphere介绍及使用

文章目录1. helm 安装及使用概述1.1 helm 安装1.1.1 添加仓库1.2 helm 常用命令2. dashboard 部署使用2.1 安装helm repo 源2.2 安装dashboard2.3 查看dashboard 运行状态2.4 创建dashboard-admin.yaml文件2.5 创建登录用户2.6 查看admin-user账户的token2.7 登录dashboard2.8 …
阅读更多...
非对称加密实战(二)：解决web项目不支持https问题 ，添加证书【附源码】

非对称加密实战(二)：解决web项目不支持https问题 ，添加证书【附源码】

目录web项目http请求变为https请求解决无法访问https问题重启再次访问https出现链接不安全,但是可以继续访问认证文件加入域名参数生成客户端认证文件证书安装源码地址web项目 http请求变为https请求 http请求 https请求 解决无法访问https问题 需要把 非对称加密实战(一…
阅读更多...
【博客576】警惕docker本身iptables规则对网络的影响

【博客576】警惕docker本身iptables规则对网络的影响

警惕docker本身iptables规则对网络的影响 警惕1&#xff1a;k8s环境下&#xff0c;独立拉取docker容器时&#xff0c;进行端口映射会有问题 场景&#xff1a; 在k8s节点由于某种原因&#xff0c;比如&#xff1a;需要拉起一个docker环境来制作镜像&#xff0c;需要拉起一些不…
阅读更多...
靶机测试Os-hacknos-3笔记

靶机测试Os-hacknos-3笔记

靶机介绍Difficulty: IntermediateFlag: 2 Flag first user And the second rootLearning: Web Application | Enumeration | Privilege EscalationWeb-site: www.hacknos.comContact-us : rahul_gehlautThis works better with VirtualBox rather than VMware靶机地址https://…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023