System 发布的文章

2024-09-04

所有,redis

主从模式：

主从模式是Redis中最简单的复制模式，一个主节点（Master）可以有一个或多个从节点（Slave）。数据是从主节点向从节点复制的，因此从节点是主节点的副本。主节点负责处理命令请求，而从节点仅复制主节点的数据。

哨兵模式：

哨兵模式是为了实现主节点的自动故障转移。哨兵是特殊的Redis进程，它们能够监控主节点和从节点，并且在主节点出现故障时自动进行故障转移。哨兵本身也是分布式的，所以它们需要互相协商来决定谁是leader，谁是follower。

集群模式：

集群模式是为了提供更好的并发处理能力和数据分布式存储。在集群模式下，Redis会将不同的数据分配到不同的节点上，每个节点只负责自己的一部分数据。集群模式通过分片（Sharding）来实现数据的分布式存储。

示例代码（主从模式配置）：




# 在从节点的配置文件中添加如下配置
slaveof <master-ip> <master-port>

示例代码（哨兵模式配置）：




# 在哨兵的配置文件中添加如下配置
sentinel monitor mymaster <master-ip> <master-port> <quorum>
sentinel down-after-milliseconds mymaster <milliseconds>
sentinel parallel-syncs mymaster <numslaves>
sentinel failover-timeout mymaster <milliseconds>

示例代码（集群模式配置）：




# 在集群的配置文件中添加如下配置
cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout <milliseconds>
appendonly yes

tomcat多实例配置-Linux(CentOS)

2024-09-04

所有,java

在Linux（CentOS）上配置多个Tomcat实例，你需要执行以下步骤：

安装Java环境（如果尚未安装）。
下载多个Tomcat压缩包。
解压缩到不同的目录。
配置不同的端口号。
启动不同的Tomcat实例。

以下是具体的命令和配置步骤：




# 安装Java（如果已安装请跳过）
sudo yum install java-1.8.0-openjdk-devel
 
# 检查Java版本
java -version
 
# 下载Tomcat（以Tomcat 9为例，请从Tomcat官网下载相应版本）
wget https://dlcdn.apache.org/tomcat/tomcat-9/v9.0.65/bin/apache-tomcat-9.0.65.tar.gz
 
# 解压第一个实例到 /usr/local/tomcat9（你可以选择任何目录）
sudo tar xzf apache-tomcat-9.0.65.tar.gz -C /usr/local/
sudo mv /usr/local/apache-tomcat-9.0.65 /usr/local/tomcat9
 
# 复制第一个实例以创建第二个实例，例如创建第二个实例到 /usr/local/tomcat9_2
sudo cp -R /usr/local/tomcat9 /usr/local/tomcat9_2
 
# 编辑第一个实例的配置文件（端口号等）
sudo nano /usr/local/tomcat9/conf/server.xml
 
# 修改以下几个地方（以Tomcat 9的默认配置为例，请根据实际情况修改）:
#   <Connector port="8080" protocol="HTTP/1.1" ... />
#   <Connector port="8009" protocol="AJP/1.3" ... />
#   <Server port="8005" ... />
 
# 同样编辑第二个实例的配置文件
sudo nano /usr/local/tomcat9_2/conf/server.xml
 
# 确保修改的端口号不冲突，例如可以将所有的8080改为9080，8009改为9009等
 
# 启动第一个实例
sudo /usr/local/tomcat9/bin/startup.sh
 
# 启动第二个实例
sudo /usr/local/tomcat9_2/bin/startup.sh
 
# 检查日志文件确认是否启动成功
sudo nano /usr/local/tomcat9/logs/catalina.out
sudo nano /usr/local/tomcat9_2/logs/catalina.out
 
# 访问第一个实例
curl http://localhost:8080
 
# 访问第二个实例
curl http://localhost:9080

确保修改端口号时遵循网络策略和防火墙设置。如果你在不同的机器或者使用不同的IP，你可能还需要修改server.xml中的<Engine>标签的name属性，以及<Host>标签的appBase属性，以确保各个实例拥有独立的应用部署路径。

Django项目--用户注册（个人练手）

2024-09-04




from django.contrib.auth.models import User
from django.contrib import messages
from django.shortcuts import render, redirect
from django.contrib.auth.decorators import login_required
 
@login_required
def register(request):
    if request.method == 'POST':
        username = request.POST['username']
        password = request.POST['password']
        email = request.POST['email']
 
        # 检查用户名是否已存在
        if User.objects.filter(username=username).exists():
            messages.error(request, 'Username is taken')
        else:
            user = User.objects.create_user(username=username, password=password, email=email)
            user.save()
            messages.success(request, 'Registration successful')
            return redirect('home')
 
    return render(request, 'register.html')

这段代码首先导入了必要的Django模块，并使用了login_required装饰器来确保只有登录用户可以访问注册页面。在POST请求中，它会创建一个新用户并保存到数据库，如果用户名已存在则显示错误消息。最后，它将成功消息添加到请求的消息框架中并重定向到主页。注意，这里假设已经有一个名为'home'的视图处理主页的请求。

LLMs-入门二：基于google云端Colab部署Llama 2

2024-09-04

所有,AIGC

在Google Colab上部署Llama 2的步骤如下：

打开Google Colab。
连接到Google Drive。
上传Llama 2模型到Google Drive。
安装必要的库。
运行部署代码。

以下是一个简化的Python代码示例，用于在Google Colab上部署Llama 2：




# 步骤1和2: 连接到Google Drive并上传模型
from google.colab import drive
drive.mount('/content/drive')
 
# 步骤4: 安装必要的库
!pip install llama_2_deploy
 
# 步骤5: 运行部署代码
import llama_2_deploy
 
llama_2_deploy.deploy(
    model_path='/content/drive/MyDrive/llama_2',  # 你的模型在Google Drive中的路径
    port=8080,  # 部署的端口号
    device='cuda'  # 使用的设备，可以是'cpu'或'cuda'
)
 
print("Llama 2 服务已启动，访问 http://localhost:8080")

确保将model_path更改为你的Llama 2模型在Google Drive中的实际路径。这段代码将会在Colab的环境中部署Llama 2，并允许你在Web浏览器中通过指定的端口访问它。

2024-09-04

以下是使用Spring Boot和MongoDB的一个简单示例，包括增删查改操作：

在pom.xml中添加依赖：




<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-mongodb</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

配置application.properties或application.yml以连接到MongoDB：




spring.data.mongodb.uri=mongodb://localhost:27017/your_database

创建一个实体类：




import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
 
@Document
public class YourEntity {
    @Id
    private String id;
    private String name;
    // 省略getter和setter
}

创建一个MongoDB仓库接口：




import org.springframework.data.mongodb.repository.MongoRepository;
 
public interface YourEntityRepository extends MongoRepository<YourEntity, String> {
}

创建一个服务类：




import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
import java.util.List;
import java.util.Optional;
 
@Service
public class YourEntityService {
 
    @Autowired
    private YourEntityRepository repository;
 
    public List<YourEntity> findAll() {
        return repository.findAll();
    }
 
    public Optional<YourEntity> findById(String id) {
        return repository.findById(id);
    }
 
    public YourEntity save(YourEntity entity) {
        return repository.save(entity);
    }
 
    public void deleteById(String id) {
        repository.deleteById(id);
    }
}

创建一个控制器类：




import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
 
import java.util.List;
import java.util.Optional;
 
@RestController
@RequestMapping("/your-entities")
public class YourEntityController {
 
    @Autowired
    private YourEntityService service;
 
    @GetMapping
    public List<YourEntity> getAll() {
        return service.findAll();
    }
 
    @GetMapping("/{id}")
    public Optional<YourEntity> getById(@PathVariable String id) {
        return service.findById(id);
    }
 
    @PostMapping
    public YourEntity create(@RequestBody YourEntity entity) {
        return service.save(ent

linux系统，ubuntu安装英伟达NVIDIA4090显卡驱动

2024-09-04

在Ubuntu系统上安装NVIDIA GeForce RTX 4090显卡驱动程序，可以通过以下步骤进行：

打开终端。
确保系统是最新的：
```
sudo apt update
sudo apt upgrade
```

添加NVIDIA PPA（个人软件包存档）到系统中：




sudo add-apt-repository ppa:graphics-drivers/ppa
sudo apt update

安装NVIDIA驱动：
```
sudo ubuntu-drivers autoinstall
```
或者，你可以使用apt搜索可用的驱动版本，然后选择一个特定版本安装：
```
ubuntu-drivers devices
sudo apt install nvidia-driver-460
```
重启电脑：
```
sudo reboot
```
安装完成后，验证驱动程序安装成功：
```
nvidia-smi
```

以上步骤会自动下载、安装NVIDIA GeForce RTX 4090显卡的驱动程序，并重启系统以使驱动生效。请确保你的系统满足了NVIDIA驱动的最小要求，并在执行这些步骤之前备份重要数据。

redis主从复制、哨兵模式、cluster集群

2024-09-04

所有,redis

Redis主从复制是指将一个Redis服务器的数据复制到其他服务器，其中一个作为主（master），其余的作为从（slave）。

主从复制配置：
在从服务器的配置文件中加入以下指令：




slaveof <master-ip> <master-port>

哨兵模式是一种机制，用于在主服务器宕机时自动将从服务器升级为新的主服务器。
哨兵模式配置步骤：

修改Redis主服务器配置文件，添加：




sentinel monitor <master-name> <master-ip> <master-port> <quorum>
sentinel down-after-milliseconds <master-name> <milliseconds>
sentinel parallel-syncs <master-name> <numslaves>

为每个Redis从服务器创建一个Sentinel实例，配置文件中指定哨兵监控的主服务器。

Cluster集群是一组独立的Redis服务器，它们分布存储数据并共同服务。
Cluster集群配置步骤：

修改每个Redis服务器配置文件，添加：




cluster-enabled yes
cluster-config-file nodes.conf
cluster-node-timeout <milliseconds>
appendonly yes

启动所有Redis服务器，它们会自动分配槽（slot）并形成集群。

注意：以上配置步骤仅为示例，实际配置时需要根据具体环境调整参数。

Oracle 到 MySQL 数据库迁移

2024-09-04

Oracle到MySQL的数据库迁移通常涉及以下步骤：

分析Oracle数据库结构和数据类型，确保它们兼容MySQL。
使用工具（如Oracle Data Pump, Oracle SQL Developer, or Oracle Enterprise Manager）导出Oracle数据库为SQL文件。
修改导出的SQL文件，以适应MySQL语法和数据类型。
在MySQL中创建数据库和表结构。
执行修改后的SQL文件，将数据导入MySQL数据库。
验证数据是否完整且所有应用程序功能正常。

以下是一个简化的例子，展示如何在Oracle中导出和在MySQL中导入数据。

Oracle导出（使用SQL*Plus或Data Pump）:




-- 使用SQL*Plus导出用户scott的所有对象和数据
expdp scott/tiger@oracle_db directory=datapump_dir dumpfile=scott_exp.dmp logfile=scott_exp.log

修改导出的SQL文件以适应MySQL（手动或使用工具）:




-- 将Oracle数据类型转换为MySQL兼容类型
CREATE TABLE my_table (
    my_id NUMBER(10) NOT NULL,
    my_name VARCHAR2(50) NOT NULL
)
-- 转换为
CREATE TABLE my_table (
    my_id INT NOT NULL,
    my_name VARCHAR(50) NOT NULL
);

在MySQL中导入数据:




-- 首先在MySQL中创建数据库和表
CREATE DATABASE my_db;
USE my_db;
CREATE TABLE my_table (
    my_id INT NOT NULL,
    my_name VARCHAR(50) NOT NULL
);
 
-- 然后导入数据
SOURCE /path/to/modified_scott_exp.sql;

请注意，实际迁移可能涉及更复杂的数据类型转换和解决方案，包括存储过程、触发器、包、函数等的迁移。可能需要使用第三方工具（如Oracle SQL Developer, Toad for Oracle,或开源迁移工具如Open Source Migration Workbench）来简化这个过程。

2024-09-04

所有,java

在Spring Cloud使用Nginx代理后端的Gateway网关时，默认情况下，Nginx会将请求代理给Gateway服务，并且可能会隐藏用户的真实IP。为了让Gateway能够获取用户的真实IP地址，需要配置Nginx以及Gateway服务。

配置Nginx，在nginx.conf或对应的server块中，添加以下配置：




location / {
    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;
    proxy_set_header Host $http_host;
    proxy_pass http://your_gateway_backend;
}

这里的关键是X-Real-IP和X-Forwarded-For头，它们会将用户的真实IP传递给Gateway。

在Spring Cloud Gateway中，可以通过添加一个过滤器来获取这些头部信息，并将其放入请求的元数据中，以便后续的过滤器或路由可以使用它们。




@Bean
public GatewayFilter xForwardedHeadersFilter() {
    return (exchange, chain) -> chain.filter(exchange)
            .then(Mono.fromRunnable(() -> {
                ServerHttpRequest request = exchange.getRequest();
                HttpHeaders headers = request.getHeaders();
                String realIp = headers.getFirst("X-Real-IP");
                String forwardedFor = headers.getFirst("X-Forwarded-For");
                // 如果有多个IP，通常X-Forwarded-For的格式是"ip1, ip2, ..."
                if (realIp != null) {
                    log.info("Real IP: " + realIp);
                }
                if (forwardedFor != null) {
                    log.info("Forwarded For: " + forwardedFor);
                }
                // 可以将这些信息放入请求的元数据中，供后续逻辑使用
                // exchange.getAttributes().put("X-Real-IP", realIp);
                // exchange.getAttributes().put("X-Forwarded-For", forwardedFor);
            }));
}

在上面的代码中，我们定义了一个名为xForwardedHeadersFilter的GatewayFilter，它会从请求头中提取X-Real-IP和X-Forwarded-For，并记录它们。然后可以将它们放入请求的元数据中，或者根据需求进行其他处理。

将过滤器应用到路由中：




@Bean
public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
    return builder.routes()
            .route("my_route", r -> r.path("/mypath/**")
                    .filters(f -> f.filter(xForwardedHeadersFilter()))
                    .uri("http://myservice"))
            .build();
}

在这个例子中，我们定义了一个名为my_route的路由，并将我们之前定义的

【微服务】springboot 整合 SA-Token 使用详解

2024-09-04

所有,java




import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import cn.dev33.satoken.SaManager;
import cn.dev33.satoken.config.SaTokenConfig;
import cn.dev33.satoken.stp.StpInterface;
import cn.dev33.satoken.spring.SaTokenSpringUtil;
 
/**
 * Sa-Token 配置类 
 */
@Configuration
public class SaTokenConfigure implements WebMvcConfigurer {
 
    // 配置Sa-Token的全局配置参数
    @Bean
    public SaTokenConfig getSaTokenConfig() {
        return new SaTokenConfig()
                .setTokenName("satoken")
                .setTimeout(1800) // 指定token的默认超时时间为30分钟
                .setActivityTimeout(-1); // 指定用户活跃时间为-1，代表永不过期
    }
 
    // 注册Sa-Token的接口实现
    @Bean
    public StpInterface getStpInterface() {
        return new StpInterface() {
            // 返回一个用户的唯一标识，如用户id
            @Override
            public Object getLoginId(Object user) {
                return ((User) user).getId();
            }
 
            // 返回此用户的权限字符串集合，例如：Set<String> 
            @Override
            public List<String> getPermissionList(Object loginId, String loginType) {
                // 这里可以根据实际情况，从数据库获取用户权限集合
                return null;
            }
 
            // 返回此用户的角色字符串集合，例如：Set<String> 
            @Override
            public List<String> getRoleList(Object loginId, String loginType) {
                // 这里可以根据实际情况，从数据库获取用户角色集合
                return null;
            }
        };
    }
 
    // 注册Sa-Token的SpringUtil
    @Bean
    public SaTokenSpringUtil getSaTokenSpringUtil() {
        return new SaTokenSpringUtil();
    }
 
    // 注册Sa-Token的拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 注册Sa-Token的Session拦截器，打开注解功能
        registry.addInterceptor(new SaInterceptor(SaManager.getConfig()))
                .addPathPatterns("/**") // 拦截所有请求
                .excludePathPatterns("/static/**", "/login"); // 排除静态资源与登录接口
    }
}

这段代码展示了如何在Spring Boot项目中配置和使用Sa-Token。首先，我们定义了一个SaTokenConfigure类，实现了WebMvcConfigurer接口，在这个类中我们配置了Sa-Token的全局配置参数，并注册了自定义的