在这个示例中，我们将使用Nginx作为反向代理服务器，将静态内容如图片、CSS、JavaScript文件等由Nginx处理，而JSP等动态内容则代理给Tomcat服务器处理。

1. 安装Nginx和Tomcat。

2. 配置Tomcat服务器：

   修改Tomcat的server.xml配置文件，设置Connector的protocol属性为HTTP/1.1，并设置connectionTimeout、redirectPort和enableLookups属性。

3. 配置Nginx：

   编辑Nginx的配置文件（通常是nginx.conf），添加一个server块来处理静态内容，并将动态请求代理到Tomcat服务器。

http {
    ...
    server {
        listen       80;
        server_name  localhost;
 
        # 静态文件处理
        location ~* \.(jpg|jpeg|png|css|js|ico|html|htm)$ {
            root /path/to/static/files;
            expires 30d;
        }
 
        # 动态内容代理到Tomcat
        location / {
            proxy_pass http://tomcat_server_ip:tomcat_server_port;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        }
    }
    ...
}

4. 重启Nginx服务器，使配置生效。
5. 测试配置是否成功，分别请求静态和动态内容，确保Nginx正确处理静态文件，并且请求被代理到Tomcat服务器。

这样，你的网站就实现了动静分离，静态内容由Nginx直接处理，动态内容由Tomcat处理，从而提高了网站的加载速度。

在使用Nginx作为反向代理时，客户端的真实IP地址可能会被Nginx代理头信息（如X-Forwarded-For）所隐藏。为了获取真实的客户端IP地址，你需要在Nginx配置中设置相应的代理头信息。

以下是一个Nginx配置的例子，它设置了X-Real-IP和X-Forwarded-For头，以便在应用程序中获取客户端的真实IP地址：

http {
    # ...
 
    map $http_x_forwarded_for $proxy_add_x_forwarded_for {
        default $http_x_forwarded_for;
        '' $remote_addr;
    }
 
    server {
        # ...
 
        location / {
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_pass http://backend_server;
        }
    }
}

在这个配置中，proxy_set_header X-Real-IP $remote_addr; 确保了真实的客户端IP地址被传递到了后端服务器。如果X-Forwarded-For头不存在，proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; 确保了只有真实的IP地址被添加到该头中。

在你的应用程序中，你可以根据你使用的编程语言来解析这些头信息以获取客户端的真实IP地址。例如，在Python中，你可以使用以下代码来获取IP地址：

from flask import request
 
def get_real_ip():
    x_forwarded_for = request.headers.get('X-Forwarded-For')
    if x_forwarded_for:
        ip = x_forwarded_for.split(',')[0]
    else:
        ip = request.remote_addr
    return ip

在上面的Python代码片段中，我们首先尝试从X-Forwarded-For头获取IP地址，如果不存在，我们就使用request.remote_addr。这样，无论客户端是直接连接还是通过代理连接，你的应用程序都能获取到真实的IP地址。

在Java后端开发中，实现跨域访问主要有以下四种方式：

1. 通过@CrossOrigin注解：这是Spring Framework提供的一个注解，用于快速实现跨域支持。

@CrossOrigin(origins = "http://domain.com")
@RestController
public class MyController {
    // ...
}

2. 全局配置：通过实现WebMvcConfigurer接口，并覆盖addCorsMappings方法，可以全局配置跨域访问。

@Configuration
public class MyConfiguration implements WebMvcConfigurer {
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**").allowedOrigins("http://domain.com");
    }
}

3. 使用Filter：通过自定义Filter添加跨域的相关headers。

@Component
public class SimpleCORSFilter implements Filter {
 
    @Override
    public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
        HttpServletResponse response = (HttpServletResponse) res;
        response.setHeader("Access-Control-Allow-Origin", "http://domain.com");
        response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE");
        response.setHeader("Access-Control-Max-Age", "3600");
        response.setHeader("Access-Control-Allow-Headers", "x-requested-with");
        chain.doFilter(req, res);
    }
 
    // ...
}

4. 使用CorsFilter：这是一个更为通用的方式，通过Java CORS Filter库或自定义实现Filter接口来设置跨域。

@Bean
public CorsFilter corsFilter() {
    UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
    CorsConfiguration config = new CorsConfiguration();
    config.setAllowCredentials(true);
    config.addAllowedOrigin("http://domain.com");
    config.addAllowedHeader("*");
    config.addAllowedMethod("*");
    source.registerCorsConfiguration("/**", config);
    return new CorsFilter(source);
}

这四种方式的优先级依次递增，即Filter > 全局配置 > @CrossOrigin注解 > CorsFilter。通常情况下，推荐使用全局配置或者@CrossOrigin注解，因为它们更为简洁和集成在框架中。

在Mac上安装Homebrew、MySQL、Redis、Nginx和Tomcat的步骤如下：

1. 安装Homebrew：

   打开终端，运行以下命令安装Homebrew：

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

2. 使用Homebrew安装MySQL：

brew install mysql

3. 使用Homebrew安装Redis：

brew install redis

4. 使用Homebrew安装Nginx：

brew install nginx

5. 使用Homebrew安装Tomcat：

brew install tomcat

安装完成后，您可以通过运行以下命令来启动各个服务：

• 启动MySQL：

brew services start mysql

• 启动Redis：

brew services start redis

• 启动Nginx：

brew services start nginx

• 启动Tomcat：

catalina start

注意：Tomcat不是作为服务安装的，需要直接运行catalina start来启动。

以上命令将在后台启动服务，您可以通过访问默认端口（MySQL通常是3306，Redis通常是6379，Nginx通常是8080，Tomcat通常是8080）来验证是否正常运行。

多实例部署：

如果你指的是Tomcat的多实例部署，通常是在同一台服务器上运行多个Tomcat服务实例。每个实例可以运行不同的应用，配置不同的端口等。

Nginx+Tomcat负载均衡配置示例：

http {
    upstream tomcat_server {
        server 127.0.0.1:8080;
        server 127.0.0.1:8081;
    }
 
    server {
        listen 80;
 
        location / {
            proxy_pass http://tomcat_server;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        }
    }
}

动静分离：

动静分离是为了提升网站性能，将网站中的动态资源（如jsp、servlet）和静态资源（html、css、js、图片等）分开处理。

以下是一个简单的Nginx配置示例，将静态资源交给Nginx处理，动态资源转发到后端Tomcat服务器。

server {
    listen 80;
 
    location / {
        root /path/to/static/files;
        try_files $uri $uri/ =404;
    }
 
    location ~ \.(jsp|do|action)$ {
        proxy_pass http://tomcat_server;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

在这个配置中，所有静态文件请求都会直接由Nginx处理，如果是动态资源请求（以.jsp、.do、.action结尾的URL），则会被转发到Tomcat服务器。

在Nginx中配置反向代理以访问Tomcat服务器，你需要编辑Nginx的配置文件（通常是nginx.conf），并设置一个代理服务器块。以下是一个简单的配置示例：

http {
    # ...
 
    upstream tomcat_server {
        server tomcat:8080; # 假设Tomcat运行在名为tomcat的服务器上的8080端口
    }
 
    server {
        listen 80;
 
        location / {
            proxy_pass http://tomcat_server; # 转发到Tomcat服务器
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
        }
 
        # 其他配置...
    }
 
    # ...
}

在这个配置中：

• upstream 块定义了一个名为tomcat_server的服务器组，其中包含了运行Tomcat的服务器和端口。
• server 块定义了监听80端口的服务器。
• location / 块指定了当请求到达该位置时，应将请求通过proxy_pass转发到tomcat_server。
• proxy_set_header 指令用于设置转发给Tomcat的请求头，以确保Tomcat接收到正确的原始主机信息和客户端IP地址。

确保Nginx配置文件语法正确，可以使用nginx -t命令进行测试，然后重启Nginx以应用更改：

sudo nginx -s reload

现在，Nginx将作为反向代理服务器，转发到Tomcat服务器的请求。

# 更新软件包列表
sudo apt update
 
# 安装 Nginx
sudo apt install nginx
 
# 启动 Nginx 服务
sudo systemctl start nginx
 
# 设置 Nginx 服务开机自启
sudo systemctl enable nginx
 
# 查看防火墙状态
sudo ufw status
 
# 允许 80 端口（HTTP）通过防火墙
sudo ufw allow 'Nginx Full'
 
# 重新加载防火墙规则
sudo ufw disable
sudo ufw enable
 
# 检查 Nginx 服务状态
sudo systemctl status nginx

以上命令将会更新系统软件包，通过apt安装Nginx，启动并设置开机自启动Nginx服务，查看防火墙状态，允许Nginx所需的端口（默认是80）通过防火墙，并重新加载防火墙规则。最后，检查Nginx服务的运行状态。

以下是一个简化的示例，展示了如何配置Nginx以实现Tomcat的负载均衡和静态资源的分离。

nginx.conf 配置文件示例：

user  nginx;
worker_processes  1;
 
events {
    worker_connections  1024;
}
 
http {
    include       mime.types;
    default_type  application/octet-stream;
 
    # 日志格式
    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';
 
    # 访问日志
    access_log  logs/access.log  main;
 
    # 静态文件目录
    sendfile        on;
    keepalive_timeout  65;
 
    # 用于动态分离的代理服务器
    upstream dynamic {
        server tomcat1:8080;
        server tomcat2:8080;
    }
 
    # 用于静态资源的服务器
    server {
        listen       80;
        server_name  localhost;
 
        # 静态资源位置
        location /static/ {
            root   /usr/share/nginx/html;
            expires 30d;
        }
 
        # 所有其他请求代理到Tomcat服务器
        location / {
            proxy_pass http://dynamic;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        }
    }
}

在这个配置中，Nginx监听80端口，并根据请求的URL将流量代理到名为dynamic的上游服务器组。所有静态资源都被直接从/usr/share/nginx/html/static/目录提供，并设置了30天的缓存。对于动态内容，请求被转发到Tomcat服务器，默认为8080端口，这些服务器通过tomcat1和tomcat2标识。

确保Tomcat服务器正确配置，并且Nginx的配置文件路径符合您的服务器环境。在实际部署时，可能需要调整root指令以指向您的静态资源目录，并可能需要修改upstream部分以反映您的Tomcat服务器的实际地址和端口。

在这个实验中，我们将使用LVS-DR模式，Keepalived和Nginx实现高可用负载均衡器，动静分离以及Tomcat作为Web服务器。以下是实现这些功能的基本步骤：

1. 配置LVS-DR模式的负载均衡器。
2. 安装和配置Keepalived实现高可用性。
3. 安装和配置Nginx作为反向代理服务器，实现动静分离。
4. 配置Tomcat服务器以托管Web应用程序。

以下是相关的配置文件和命令示例：

LVS-DR模式负载均衡器的配置：

# 安装ipvsadm
yum install ipvsadm -y
 
# 设置LVS路由，确保数据包不会在Director之间循环
echo 1 > /proc/sys/net/ipv4/ip_forward
 
# 设置ARP过滤，避免ARP洪泛播
echo 1 > /proc/sys/net/ipv4/conf/all/arp_ignore
echo 2 > /proc/sys/net/ipv4/conf/all/arp_announce
 
# 添加LVS规则
ipvsadm -C
ipvsadm -A -t 192.168.1.100:80 -s rr
ipvsadm -a -t 192.168.1.100:80 -r 192.168.1.11 -g
ipvsadm -a -t 192.168.1.100:80 -r 192.168.1.12 -g

Keepalived配置：

# 安装Keepalived
yum install keepalived -y
 
# 编辑Keepalived配置文件
global_defs {
   router_id LVS_DEVEL
}
 
vrrp_instance VI_1 {
    state MASTER
    interface eth0
    virtual_router_id 51
    priority 100
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass 1111
    }
    virtual_ipaddress {
2.168.1.100
    }
}

Nginx配置（动静分离）：

# 安装Nginx
yum install nginx -y
 
# 编辑Nginx配置文件
http {
    upstream tomcat_server {
        server 192.168.1.13:8080;
        server 192.168.1.14:8080;
    }
 
    server {
        listen 80;
        server_name localhost;
 
        location / {
            proxy_pass http://tomcat_server;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        }
 
        location ~* \.(jpg|jpeg|png|css|js|ico|html)$ {
            root /data/webapps/static;
            expires 30d;
        }
    }
}

Tomcat服务器配置：

# 安装Tomcat
yum install tomcat -y
 
# 配置Tomcat实例，确保它监听在8080端口

这些是基本的配置和命令，具体的配置文件和命令可能会根据实际环境有所不同。在实际部署时，还需要考虑网络配置、防火墙规则、服务器安全性等因素。

# 在OpenResty中配置多级缓存
 
http {
    # ...
 
    upstream tomcat_server {
        server 127.0.0.1:8080;
    }
 
    server {
        listen 80;
 
        # 配置本地缓存
        location /local_cache/ {
            # 设置本地缓存存储路径
            proxy_cache_path /data/nginx/cache levels=1:2 keys_zone=my_cache:10m max_size=10g inactive=60m use_temp_path=off;
 
            # 启用缓存
            proxy_cache my_cache;
 
            # 缓存有效期
            proxy_cache_valid 200 1d;
 
            # 代理设置
            proxy_pass http://tomcat_server;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
 
            # 设置缓存键
            proxy_cache_key $uri$is_args$args;
        }
 
        # 配置Redis缓存
        location /redis_cache/ {
            # 设置Redis连接参数
            set $redis_key $uri$is_args$args;
            redis_pass 127.0.0.1:6379;
 
            # 设置缓存查询失败时的回退处理
            default_type text/plain;
            error_page 404 = @tomcat;
 
            # 从Redis缓存中获取数据
            redis_code 200 "get $redis_key";
 
            # 设置缓存有效期
            redis_code 200 "expire $redis_key 1d";
        }
 
        # 请求未命中Redis缓存时，代理到Tomcat服务器
        location @tomcat {
            proxy_pass http://tomcat_server;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
 
            # 将响应数据存储到Redis缓存中
            proxy_store on;
            proxy_store_access user:rw group:rw all:rw;
            proxy_temp_path /data/nginx/temp;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_pass_request_body off;
            proxy_pass_request_headers on;
            proxy_connect_timeout 10s;
            proxy_send_timeout 10s;
            proxy_read_timeout 10s;
 
            # 设置数据存储到Redis的键和过期时间
            set $redis_key $uri$is_args$args;
            set_by_lua_block $redis_expire $msec {
                return tonumber(ngx.var.msec) + 86400000;
            }
            lua_shared_dict msec 1m;
            lua_shared_dict redis_commands 1m;
            content_by_lua_block {
                local msec = ngx.shared.msec