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

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，进行下一场轮询。

3 资源池——天翼云4.0

广义的天翼云4.0——SateCloud

全面自研——全新一代，始于2021，拥有 分布式云架构 和 云网融合创新 两大核心优势，从“2+4+21+X”的天翼云3.0到“千城万池”的天翼云4.0

4 “西南1”产品介绍

4.1 多AZ ——公有云的核心灵魂

作为第七代云主机，采用第三代Intel至强可扩展处理器（Ice Lake），基于新一代虚拟化平台，使用NUMA绑定技术。

4.2 云容灾 CT—CDR（Cloud disaster recovery）

关键特性（注意，容灾迁移两边的地址不一样）：

ESC跨AZ容灾能力

PS ：块存储不加容灾能力无法跨AZ容灾

4.3 服务能力

4.3.1 内网 DNS

4.3.2 数据迁移服务

注意，云硬盘并非利用了纠错冗余码技术，而是采用了三分块技术使得数据不丢失。