Linux负载均衡器

最新推荐文章于 2026-03-12 01:42:53 发布
原创 最新推荐文章于 2026-03-12 01:42:53 发布 · 657 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

    这次主要是想上传一下代码，写了一个负载均衡器。

//客户端代码：

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<assert.h>
#include<sys/un.h>
#include<arpa/inet.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<error.h>
#include<string.h>
const int BUFF_SIZE = 128;
const char *ip = "127.0.0.1";

int conn(int port)
{
    int sockfd = socket(AF_INET,SOCK_STREAM,0);
    assert(sockfd>0);

    struct sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    inet_pton(AF_INET,ip,&saddr.sin_addr);
    saddr.sin_port = htons(port);

    int res = connect(sockfd,(struct sockaddr*)&saddr,sizeof(saddr));
    if(res<0)
    {
        close(sockfd);
        return -1;
    }
    return sockfd;
}

int main(int argc,char *argv[])
{
    int load_sockfd = conn(6500);
    if(load_sockfd<0)
    {
        printf("connect load error\n");
        return 1;
    }
    else
    {
        printf("connect load succese\n");
    }
    char buf[5];
    memset(buf,0,5);
    int n = recv(load_sockfd,buf,5,0);
    if(n <= 0)
    {
        printf("load close\n");
        close(load_sockfd);
        return 1;
    }
    int port = atoi(buf);
    
    printf("port = %d\n",port);
    n = send(load_sockfd,"ok",2,0);
    if(n<0)
    {
        printf("load close\n");
        close(load_sockfd);
        return 1;
    }
    close(load_sockfd);

   
    int sockfd = conn(port);
    if(sockfd<0)
    {
        printf("connect server(%d) error\n",port);
        
        return 1;
    }

    while(1)
    {
        char buff[BUFF_SIZE];
        memset(buff,0,BUFF_SIZE);
        printf("input\n");
        fgets(buff,127,stdin);

        int n = send(sockfd,buff,BUFF_SIZE-1,0);
        if(n<0)
        {
            printf("send error\n");
            break;
        }
        memset(buff,0,127);
        n = recv(sockfd,buff,2,0);
        if(n <= 0)
        {
            printf("recv error\n");
            break;
        }
        printf("recv = %s\n",buff);
    }
    close(sockfd);
    return 0;
}
均衡器代码： 

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<assert.h>
#include<sys/un.h>
#include<arpa/inet.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<sys/epoll.h>
#include<string.h>
#include<fcntl.h>
#include<errno.h>

const int BUFF_SIZE = 128;
const int MAX_EVENT_NUMBLE = 100;
const int SERVER_NUMBLE = 5;

const char *ip = "127.0.0.1";
pthread_mutex_t mutex;


typedef struct Node
{
    int count;
    char port[5];
}NODE;

NODE server_data[5] =
{
    {0,"6600"},
    {0,"6700"},
    {0,"6800"},
    {0,"6900"},
    {0,"7000"},
};



int min_server_data()
{
    int i = 1;
    int j = 0;

    for(; i<5; ++i)
    {
        if( server_data[i].count < server_data[j].count)
        {
            j = i;
        }
    }

    ++server_data[j].count;

    printf("count   port\n");
    for(i = 0; i<5; ++i)
    {
        printf("%d      %s\n",server_data[i].count,server_data[i].port);
    }
    return j;
}



void *worker(void *arg)
{
    int cli_sockfd  = *(int*)arg;

    printf("pthread running cli_sockfd(%d)\n",cli_sockfd);

    pthread_mutex_lock(&mutex);
    int i = min_server_data();
    pthread_mutex_unlock(&mutex);

    char buff[5];
    memset(buff,0,5);
    strcpy(buff,server_data[i].port);

    int n = send(cli_sockfd,buff,5,0);
    if(n < 0)
    {
       close(cli_sockfd);
       printf("send cli(%d) error\n",cli_sockfd);
       return NULL;
    }
    memset(buff,0,5);
    n = recv(cli_sockfd,buff,2,0);
    if(n<0)
    {
       close(cli_sockfd);
       printf("recv cli(%d) error\n",cli_sockfd);
       return NULL;
    }
    printf("buff = %s\n",buff);
   
    close(cli_sockfd);
}

int main(int argc,char *argv[])
{
    if(argc<2)
    {
        printf("argc<2\n");
        return 1;
    }

    pthread_mutex_init(&mutex,NULL);

    int port = atoi(argv[1]);

    int listenfd = socket(AF_INET,SOCK_STREAM,0);
    assert(listenfd>=0);

    struct sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    inet_pton(AF_INET,ip,&saddr.sin_addr);
    saddr.sin_port = htons(port);
    
    int res = bind(listenfd,(struct sockaddr*)&saddr,sizeof(saddr));
    assert(res != -1);

    res = listen(listenfd,5);
    assert(res != -1);
    
    while(1)
    {
        struct sockaddr_in caddr;
        socklen_t caddr_len = sizeof(caddr);
        int connfd = accept(listenfd,(struct sockaddr*)&caddr,&caddr_len);
        assert(connfd>0);
        printf("cli(%d) connect\n",connfd);

        pthread_t thread;
        pthread_create(&thread,NULL,&worker,&connfd);
    }
  
    close(listenfd);
    pthread_mutex_destroy(&mutex);
    return 0;
}
服务器代码： 

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<assert.h>
#include<sys/un.h>
#include<arpa/inet.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<sys/types.h>
#include<netinet/in.h>
#include<sys/epoll.h>
#include<string.h>
#include<fcntl.h>
#include<errno.h>

const int BUFF_SIZE = 128;
const int MAX_EVENT_NUMBLE = 100;

const char *ser_ip = "127.0.0.1";

typedef struct fds
{
    int epollfd;
    int sockfd;
}fds;



/*将文件描述符设置为非阻塞的*/
int setnonblocking(int fd)
{
    int old_option = fcntl(fd,F_GETFL);
    int new_option = old_option |O_NONBLOCK;
    fcntl(fd,F_SETFL,new_option);
    return old_option;
}

/*将文件描述符fd的EPOLLIN事件注册到内核事件表中，参数enable_et指定是否对FD
 采用EPOLLONESHUT事件*/

void Addfd(int epollfd,int fd,int enable_et)
{
    struct epoll_event event;
    event.data.fd = fd;
    event.events  = EPOLLIN | EPOLLET;
    if(enable_et)
    {
        event.events |= EPOLLONESHOT;
    }
    epoll_ctl(epollfd,EPOLL_CTL_ADD,fd,&event);
    setnonblocking(fd);
}

/*重置FD上的事件，这样操作以后，尽管fd上的EPOLLONESHOT事件被注册，但是操作系统仍然会触发FD上的EPOLLIN事件，且只触发一次*/
void reset_oneshot(int epollfd,int fd)
{
    struct epoll_event event;
    event.data.fd = fd;
    event.events  = EPOLLIN | EPOLLET | EPOLLONESHOT;
    epoll_ctl(epollfd,EPOLL_CTL_MOD,fd,&event);
}

void *worker(void *arg)
{
    int cli_sockfd  = ((fds*)arg)->sockfd;
    int epollfd = ((fds*)arg)->epollfd;

    printf("pthread running cli_sockfd(%d)\n",cli_sockfd);

    while(1)
    {
        char buff[BUFF_SIZE];
        memset(buff,0,BUFF_SIZE);

        int n = recv(cli_sockfd,buff,BUFF_SIZE-1,0);
        if(n == 0)
        {
            printf("cli(%d)closed the connection\n",cli_sockfd);
            close(cli_sockfd);
            break;
        }
        else if(n<0)
        {
            if(errno == EAGAIN)
            {
                reset_oneshot(epollfd,cli_sockfd);

                printf("read later\n");
                break;
            }
            close(cli_sockfd);
            break;
        }
        else
        {
            printf("recv cli(%d) : %s\n",cli_sockfd,buff);
            n = send(cli_sockfd,"ok",2,0);
            if(n<0)
            {
                printf("cli(%d) close\n");
                close(cli_sockfd);
                break;
            }
            memset(buff,0,BUFF_SIZE);
        }
        
    }



}

int main(int argc,char *argv[])
{
    if(argc<2)
    {
        printf("argc<2\n");
        return 1;
    }


    int port = atoi(argv[1]);

    int listenfd = socket(AF_INET,SOCK_STREAM,0);
    assert(listenfd>=0);

    struct sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    inet_pton(AF_INET,ser_ip,&saddr.sin_addr);
    saddr.sin_port = htons(port);
    
    int res = bind(listenfd,(struct sockaddr*)&saddr,sizeof(saddr));
    assert(res != -1);

    res = listen(listenfd,5);
    assert(res != -1);
    
    struct epoll_event events[MAX_EVENT_NUMBLE];
    int epollfd = epoll_create(5);
    assert(epollfd != -1);
    Addfd(epollfd,listenfd,0);
    
    while(1)
    {
        int ret  = epoll_wait(epollfd,events,MAX_EVENT_NUMBLE,-1);
        printf("ret = %d\n",ret);
        int i = 0;
        for(; i<ret; ++i)
        {
            int sockfd = events[i].data.fd;
            if(sockfd == listenfd)
            {
                struct sockaddr_in caddr;
                socklen_t caddr_len = sizeof(caddr);
                int connfd = accept(listenfd,(struct sockaddr*)&caddr,&caddr_len);
                assert(connfd>0);
                printf("load(%d) connect\n",connfd);
                Addfd(epollfd,connfd,1);
            }
            else if(events[i].events & EPOLLIN)
            {
                pthread_t thread;
                fds fds_work;
                fds_work.epollfd = epollfd;
                fds_work.sockfd  = sockfd;
                pthread_create(&thread,NULL,&worker,&fds_work);
            }
        }
    }
    close(listenfd);
    return 0;
}




标签
#linux #负载均衡
life_NULL
关注
lvs在linux系统下安装,CentOS 8/RHEL 8上安装和配置LVS(Linux Virtual Server)负载均衡器
weixin_30774813的博客
05-14 569
本文介绍在CentOS 8/RHEL 8操作系统上安装和配置LVS(Linux Virtual Server)负载均衡器的方法，Linux Virtual Server是在真实服务器集群上构建的高度可扩展且高度可用的服务器，负载平衡器在Linux操作系统上运行。我们将在我们的CentOS 8/RHEL 8计算机上安装Linux Virtual Server软件包，然后将其配置为后端服务器的负载平衡...
Linux 负载均衡总结（四层负载/七层负载）
追求幸福，探索未知的博客
07-11 2969
负载均衡 四层负载 七层负载
Linux四层负载均衡——LVS
hujunbo553271的专栏
03-06 2225
Linux四层负载均衡——LVS
linux进程管理(二十五)—负载均衡
奇小葩
01-29 8226
linux进程管理—负载均衡 前面主要是学习进程的调度管理，默认都是在单CPU上的调度策略，在O(1)调度后，为了减小CPU之间的干扰，就会为每个CPU上分配一个任务队列，运行的时候可能会出现有的CPU很忙，有的CPU很闲，为了避免这个问题的出现，甚至最极端的情况是，一个 CPU 的可运行进程队列拥有非常多的进程，而其他 CPU 的可运行进程队列为空，这就是著名的 一核有难，多核围观，Linux 内核实现了 CPU 可运行进程队列之间的负载均衡。 1 什么是CPU负载 提到负载，我们首先会想到命令upti
Linux系统中的负载均衡
prop428的博客
08-11 1843
在当今互联网时代，人们对计算机系统的性能和可靠性要求越来越高。为了实现系统的高效运行和充分利用服务器资源，负载均衡技术应运而生。负载均衡（Load Balancing）是一种将系统的负载均匀地分配给多个服务器或设备的技术，以提高系统的性能、可靠性和稳定性。
Linux配置nginx负载均衡
qq_59349874的博客
05-22 985
1、配置环境（需要三台服务器） 负载均衡服务器（主）192.168.43.130 后端服务器A 192.168.43.131 后端服务器B 192.168.43.132 2、开启Nginx：/usr/local/nginx/sbin/nginx 查看端口：lsof -i :80 关闭selinux：/etc/selinux/config 修改配置文件：将SELINUX=ebforcing改为SELINUX=disabled ge...
Linux上的HTTP负载均衡器
weixin_73725158的博客
02-08 192
与Nginx相比，HAProxy在配置选项上更加细致，如基于URL的负载均衡、请求重试等，为管理员提供了更多的灵活性。Nginx是一款轻量级、高性能的HTTP和反向代理服务器，同时也是一个出色的负载均衡器。例如，对于高性能和可扩展性的要求，Nginx和HAProxy是不错的选择；LVS是Linux内核层面实现的负载均衡技术，它通过修改Linux内核来实现高性能的IP负载均衡。它通过分发网络流量到多台后端服务器上，有效减轻了单一服务器的负载压力，从而提高了整个系统的响应速度和稳定性。
【Azure】创建负载均衡器连接Linux虚拟机
U2U22的博客
07-26 1193
在Azure上部署面向Internet的负载均衡器，连接两个Linux虚拟机，最终达到从外部访问一个IP地址，负载均衡器按照之前定的规则分流向两台VM。
Linux 集群总结 + LVS（负载均衡器）原理及配置
qq_41490913的博客
05-25 80
Linux 集群总结 + LVS（负载均衡器）原理及配置
在Linux中，如何配置负载均衡器以分配网络流量？
努力变的更强
01-05 704
NGINX是一款高性能的HTTP和反向代理服务器，也常用作负载均衡器。它支持多种负载均衡算法，如轮询、加权轮询、IP哈希等。
[Linux]F5负载均衡器
程序员老狼专注开发aigc或客服系统应用
08-06 1011
F5负载均衡器是硬件的负载均衡设备 F5配置最简单负载均衡，需要配置的参数有Node（节点）、Pool（资源池）、和Virtual Server（虚拟服务器），它们的关系是，先配置Node，然后配置VS。Node是最基本的定义，如每个服务器就是一个Node，负载均衡Pool是一组Node接收和处理流量的一组设备，如web服务器集群。BIGIP系统将客户机流量请求发送到Pool...
linux apache 负载均衡,使用Apache作为前端负载均衡器
weixin_29179311的博客
05-14 300
在某些场景中，我们需要在前端放置一个Apache作为负载均衡器，后台有若干台Apusic或者其它的类似于Tomcat/WebLogic等应用服务器，客户端发送到Apache的请求，将被分配到后台的这些真正完成请求的服务器上。本文描述如何使用Apache作为负载均衡器的方法。我们假设Apahce安装在 myserver 这台服务器上，并且希望用户访问 时，能够将这些请求被负载到后台的两台服务器上，分...
探索linux内核与网络编程：借助快马ai模型智能生成负载均衡器源码
最新发布
RubyLion28的博客
03-12 18
它的编辑器响应很快，内置的AI助手能很好地理解我对Linux网络编程的需求，生成的代码骨架质量很高，注释详细，为我节省了大量前期查文档和写样板代码的时间。这意味着我不仅能在本地环境运行，还可以直接将这个负载均衡器原型部署到线上，生成一个可公开访问的临时URL，方便分享和演示，整个过程不需要自己配置服务器或容器环境，非常省心。通过这个项目，我不仅实践了Linux下的socket编程、多进程模型和基本的HTTP协议，还对负载均衡器的核心工作原理有了第一手的认识。的编辑器中，我向集成的AI模型描述了上述需求。
负载均衡器--linux高性能服务器 lb
hello_bravo_的博客
10-10 1286
好几天没有更新了，因为我一直在和负载均衡器的源码抗争中，现在终于弄懂了，首先就开始说流程。    负载均衡服务器：    相当于一个中转站，其链接了许多的服务器构建成了集群，然后每个服务器都做着相同的工作，负载均衡器仅仅起到中转的作用，当客户端发送请求时，负载均衡器改变客户端的目的地，将客户端和空闲的服务器连接起来，自己继续进行监测，而客户端就和相应的服务器开始进行操作。    负载均衡器的
linux f5作用,[Linux]F5负载均衡器
weixin_30958745的博客
05-14 798
f5负载均衡器是硬件的负载均衡设备f5配置最简单负载均衡，需要配置的参数有node(节点)、pool(资源池)、和virtual server(虚拟服务器)，它们的关系是，先配置node，然后配置vs。node是最基本的定义，如每个服务器就是一个node，负载均衡pool是一组node接收和处理流量的一组设备，如web服务器集群。bigip系统将客户机流量请求发送到pool成员中的任一服务器上(n...
linux系统消息中间件安装配置负载均衡器
析木的博客
02-23 634
linux系统消息中间件rabbitmq安装配置四层负载均衡器haproxy
用 Rust 编写 eBPF/XDP 负载均衡器
sinat_40572875的博客
11-17 1136
eBPF 是一种在运行时将程序动态加载到内核中的简单有效的方法，其安全性和性能由内核本身使用即时 (JIT) 编译器和验证过程提供。使用 eBPF 可以创建多种不同类型的程序，但出于本示例的目的，我们将专注于创建可以读取和修改网络数据包的。此演示缺少生产 XDP 程序所需的一些内容，并且 Aya 本身在从现在到它的第一个v1版本之间的时间里会发生重大变化。在当今的云生态系统中，对应用程序及其网络流量的高性能和高性能可观察性、安全性和网络功能的需求与以往一样高。x86_64的机器上构建和测试的。
linux系统haproxy负载均衡器使用keepalived做高可用
析木的博客
02-05 326
linux系统haproxy负载均衡器使用keepalived做高可用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值