公有云——天翼云4.0及负载均衡相关介绍

zylyyyyyy

于 2024-10-08 19:12:02 发布

阅读量1.6k

点赞数 34

文章标签：负载均衡运维云计算

本文链接：https://blog.csdn.net/zylyyyyyy/article/details/142757927

版权

1.3.2 Aone （All In One）：又称Access One，该产品基于CDN网络，涵盖Web应用防火墙（WAF）和 CDN加速。

3.1 广义的天翼云4.0——SateCloud

1 云计算的价值

1.1 公有云的价值

快速部署弹性伸缩按需使用高可用简化易用开放共享

1.2 公有云的一条龙服务

服务提供涵盖：

上云咨询、设计规划、部署迁移、测试调优、运维支撑

天翼云的核心优势：

云网融合

什么是云网融合？

云网融合 = 渠道+产品+技术+运维+安全+服务

1.3 天翼云强推的现有产品

1.3.1 云电脑

1.3.2 Aone （All In One）：又称Access One，该产品基于CDN网络，涵盖Web应用防火墙（WAF）和 CDN加速。

2 云上架构

2.1 架构图

下面一图看懂云架构

2.2 负载均衡算法

拓展知识——基于分布式系统的特性，我们先普及一下负载均衡算法（此处只重点介绍公有云中常用的三种）

①源地址哈希法（Hash）

源地址哈希法是根据请求来源的地址，通过哈希函数计算得到的一个数值，用该数值对服务器列表的大小进行取模运算，得到的结果便是客服端要访问服务器的序号。采用源地址哈希法进行负载均衡，同一源地址的请求，当服务器列表不变时，它每次都会映射到同一台服务器进行访问。

具体可以参考这位老师的文章：负载均衡算法--源地址哈希法（Hash）-CSDN博客

②最少连接数（Least Connections）

将新的请求发送到同时连接最少的服务实例。

代码示例，以下是使用 Least Connections 负载均衡算法，实现了对 HTTP 和 HTTPS 两种协议的负载均衡：

import http.client
import http.server
import socket
import ssl
import threading
from typing import List
 
 
# HTTP server configuration
HTTP_HOSTNAME = 'localhost'
HTTP_PORT = 8080
 
 
# HTTPS server configuration
HTTPS_HOSTNAME = 'localhost'
HTTPS_PORT = 8443
SSL_CERTIFICATE = 'localhost.crt'
SSL_PRIVATE_KEY = 'localhost.key'
 
 
# Servers and their weights
# Format: (hostname, port, weight)
SERVERS = [
    ('localhost', 5001, 3),
    ('localhost', 5002, 2),
    ('localhost', 5003, 1)
]
 
 
class LeastConnectionsBalancer:
 
 
    def __init__(self, servers: List):
        self.servers = servers
        self.connections = [0 for _ in servers]
        self.mutex = threading.Lock()
 
 
    def get_best_server(self):
        with self.mutex:
            index = 0
            current_connections = self.connections[0]
            for i, conn in enumerate(self.connections[1:]):
                if conn < current_connections:
                    index = i + 1
                    current_connections = conn
            self.connections[index] += 1
            return self.servers[index]
 
 
    def release_server(self, server_index):
        with self.mutex:
            self.connections[server_index] -= 1
 
 
class LoadBalancerHTTPHandler(http.server.BaseHTTPRequestHandler):
 
 
    balancer = LeastConnectionsBalancer(SERVERS)
 
 
    def do_GET(self):
        server = self.balancer.get_best_server()
        conn = http.client.HTTPConnection(server[0], server[1])
        conn.request('GET', self.path)
        response = conn.getresponse()
        self.send_response(response.status)
        for header, value in response.getheaders():
            self.send_header(header, value)
        self.end_headers()
        self.wfile.write(response.read())
        conn.close()
        self.balancer.release_server(SERVERS.index(server))
 
 
class LoadBalancerHTTPSHandler(http.server.BaseHTTPRequestHandler):
 
 
    balancer = LeastConnectionsBalancer(SERVERS)
 
 
    def do_GET(self):
        server = self.balancer.get_best_server()
        context = ssl.create_default_context()
        context.check_hostname = False
        context.verify_mode = ssl.CERT_NONE
        conn = http.client.HTTPSConnection(server[0], server[1], context=context)
        conn.request('GET', self.path)
        response = conn.getresponse()
        self.send_response(response.status)
        for header, value in response.getheaders():
            self.send_header(header, value)
        self.end_headers()
        self.wfile.write(response.read())
        conn.close()
        self.balancer.release_server(SERVERS.index(server))
 
 
if __name__ == '__main__':
    # Start HTTP server in a new thread.
    http_server = http.server.HTTPServer((HTTP_HOSTNAME, HTTP_PORT), LoadBalancerHTTPHandler)
    http_thread = threading.Thread(target=http_server.serve_forever)
    http_thread.daemon = True
    http_thread.start()
    print('HTTP server started on %s:%d' % (HTTP_HOSTNAME, HTTP_PORT))
 
 
    # Start HTTPS server in a new thread.
    context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
    context.load_cert_chain(SSL_CERTIFICATE, SSL_PRIVATE_KEY)
    https_server = http.server.HTTPServer((HTTPS_HOSTNAME, HTTPS_PORT), LoadBalancerHTTPSHandler)
    https_server.socket = context.wrap_socket(https_server.socket, server_side=True)
    https_thread = threading.Thread(target=https_server.serve_forever)
    https_thread.daemon = True
    https_thread.start()
    print('HTTPS server started on %s:%d' % (HTTPS_HOSTNAME, HTTPS_PORT))
 
 
    # Wait for threads to finish.
    http_thread.join()
    https_thread.join()

③静态算法——轮询（Round Robin）：将客户端请求按顺序发送到不同的服务实例。服务通常需要是无状态的。2.粘性轮询（Sticky Round Robin）：是轮询算法的改进版本。如果Alice的第一个请求发送到服务A，则以下请求也发送到服务A。3.权重轮询（Weighted Round Robin）：管理员可以为每个服务指定权重。权重更高的服务处理的请求更多。4.散列（Hash）：该算法对传入请求的IP或URL应用哈希函数。根据哈希函数结果，将请求路由到相关实例。

下面为代码示例，轮询算法的实现非常简单，可以定义一个服务器的列表和当前服务器指针：

# 服务器列表
servers = ["ServerA", "ServerB", "ServerC"]
# 当前服务器
current_server = 0
# 轮询算法
if(req):
    # 选择当前服务器来处理请求
    process_request(servers[current_server])
    # 将当前服务器移到服务器列表的末尾
 
    if current_server == length(servers):
        current_server = 0
    else:
      # 指针+1
      current_server += 1

当客户端有新的请求到达时，负载均衡器会选择服务器指针（current_server）指向的服务器来处理请求，然后将当前服务器指针移到下一个服务器（current_server += 1），如果current_server=服务器总数，则把current_server设置为0，进行下一场轮询。