分类所有下的文章

2024-09-05

在Spring Cloud Gateway中，要配置Reactor Netty的访问日志，你可以通过设置application.yml或application.properties文件中的相关属性来实现。以下是配置的例子：




logging:
  level:
    reactor.netty.http.client: DEBUG

或者使用application.properties格式：




logging.level.reactor.netty.http.client=DEBUG

这将使得Reactor Netty的HTTP客户端发出的请求和响应的详细信息都以DEBUG级别记录。你可以根据需要将日志级别从DEBUG改为INFO或ERROR。

请注意，这些配置项将会影响所有的Reactor Netty HTTP客户端行为，包括Spring WebFlux和Spring Cloud Gateway中使用的客户端。如果你只想针对Spring Cloud Gateway进行日志记录，可能需要进一步定制日志配置。

- 阅读更多 -

PG-DBA培训16：PostgreSQL负载均衡分发与双主HA架构

System

2024-09-05

所有,数据库

在PostgreSQL中，实现数据库的负载均衡和双主高可用性（HA）架构可以通过使用流复制和Patroni等工具来实现。以下是一个简化的示例，展示如何使用Patroni实现双主结构和负载均衡。

安装Patroni和PostgreSQL:




# 安装PostgreSQL
sudo apt-install postgresql
 
# 安装Patroni
sudo apt-get install python3-pip
sudo pip3 install patroni[zookeeper,etcd,consul,experimental]

配置Patroni的配置文件/etc/patroni/patroni.yml:




scope: pg_cluster
namespace: /service
name: postgres
restapi:
  listen: 0.0.0.0
  connect_address: localhost:8008
etcd:
  hosts:
  - etcd1:2379
  - etcd2:2379
  - etcd3:2379
bootstrap:
  dcs:
    ttl: 30
    loop_wait: 10
    retry_timeout: 10
    maximum_lag_on_failover: 1048576
    postgresql:
      use_pg_rewind: true
      use_slots: true
      parameters:
        max_connections: 100
        hot_standby: 'on'
        max_standby_streaming_delay: 30s
        wal_level: replica
        wal_sender_timeout: 60s
        wal_log_hints: 'on'
        max_replication_slots: 10
        max_locks_per_transaction: 64
        deadlock_timeout: '1s'
  pg_hba:
  - host all all 0.0.0.0/0 md5
  users:
    admin:
      password: 'admin-password'
      options:
        - createrole
        - createdb
postgresql:
  listen: 0.0.0.0:5432
  data_dir: /var/lib/postgresql/data
  bin_dir: /usr/lib/postgresql/bin
  pgpass: /tmp/pgpass
tags:
  nofailover: false
  noloadbalance: false
  clonefrom: false
  nosync: false

启动Patroni并配置系统启动:




patroni /etc/patroni/patroni.yml
# 将以上命令加入系统启动脚本

配置流复制:
在postgresql.conf中设置以下参数:




wal_level = replica
max_wal_senders = 3
max_replication_slots = 3
hot_standby = on

在recovery.conf中设置:




primary_conninfo = 'host=master1 port=5432 user=replicator password=rep-pass sslmode=prefer sslcompression=1'
primary_slot_name = 'slot_name'

启动流复制:




SELECT * FROM pg_create_physical_replication_slot('slot_name');

监控和管理:
使用Patroni提供的API来监控集群状态和执行故障转移。




# 获取集群状态
curl http://localhost:8008/cluster
 
# 手动触发故障转移
curl -X POST http://localhost:8008/failover

以上是一个基本的Patroni配置示例，实际部署时需要考虑更多的配置细节，如网络配置、资源限制、监控工具等。

- 阅读更多 -

PostgreSQL 内存配置与 MemoryContext 的生命周期

System

2024-09-05

所有,数据库

在PostgreSQL中，内存配置主要涉及到两个方面：共享内存和进程内存。共享内存主要用于QE（查询执行）之间的通信，而进程内存主要指的是每个QE进程可以使用的内存。

在PostgreSQL中，MemoryContext是一个抽象的内存管理结构，它负责在PostgreSQL进程的地址空间内分配和管理内存。根据其生命周期，MemoryContext可以分为以下几种类型：

TopMemoryContext：这是所有其他MemoryContext的根，它不会被释放，且在PostgreSQL进程的生命周期内持续存在。
MessageContext：用于临时存储错误或警告信息，在每次报错后会被重置。
PortalContext：管理Portal状态的内存，Portal是用户输入的SQL语句在PostgreSQL中的内部表示。
MemoryContext：这是一个最常见的内存上下文类型，用于管理例如排序、Hash表、CTE等操作中的内存。
CurTransactionContext：管理当前事务状态的内存。
PostmasterContext：管理postmaster进程的内存。

在PostgreSQL中，可以通过psql的\!命令执行操作系统命令，来查看PostgreSQL进程的内存使用情况。例如，使用ps命令和grep来查看PostgreSQL进程的内存使用情况：




\! ps aux | grep postgres | grep -v grep | awk '{print $4}'

这将显示PostgreSQL进程的内存占用百分比。

对于内存配置，PostgreSQL提供了几个参数，如shared_buffers、work_mem、maintenance_work_mem等，可以在postgresql.conf中设置，或通过ALTER SYSTEM命令在数据库运行时动态设置。

例如，设置work_mem的值：




ALTER SYSTEM SET work_mem = '64MB';

重新加载配置使之生效：




\! pg_ctl reload

以上回答基于PostgreSQL 12及以前的版本。在PostgreSQL 13及以后的版本中，内存管理有了较大变化，引入了新的内存管理器。

System

2024-09-05

所有,java

以下是一个简化的示例，展示了如何在Spring Boot应用程序中使用Spring Security和Redis进行短信验证码登录的整合。

添加依赖到pom.xml：




<dependencies>
    <!-- Spring Boot Web Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- Spring Security -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    <!-- Redis -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <!-- 短信服务接口 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-webflux</artifactId>
    </dependency>
</dependencies>

配置application.properties或application.yml：




spring.redis.host=localhost
spring.redis.port=6379

创建SmsCodeAuthenticationToken类：




public class SmsCodeAuthenticationToken extends AbstractAuthenticationToken {
    private final Object principal;
    private Object credentials;
 
    public SmsCodeAuthenticationToken(String mobile) {
        super(null);
        this.principal = mobile;
        setAuthenticated(false);
    }
 
    public SmsCodeAuthenticationToken(Object principal, Object credentials, Collection<? extends GrantedAuthority> authorities) {
        super(authorities);
        this.principal = principal;
        this.credentials = credentials;
        super.setAuthenticated(true);  // must use super, as we override
    }
 
    // Required for Spring Security
    @Override
    public Object getCredentials() {
        return this.credentials;
    }
 
    // Required for Spring Security
    @Override
    public Object getPrincipal() {
        return this.principal;
    }
 
    // Required for Spring Security
    @Override
    public void setAuthenticated(boolean isAuthenticated) throws IllegalArgumentException {
        if (isAuthenticated) {
            throw new IllegalArgumentException(
                    "Cannot set this token to trusted - use constructor which takes a GrantedAuthorit

System

2024-09-05

所有,数据库




from flask import Flask
from flask_sqlalchemy import SQLAlchemy
 
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///blog.db'
db = SQLAlchemy(app)
 
class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)
 
    def __repr__(self):
        return '<User %r>' % self.username
 
@app.route('/')
def index():
    return '<h1>Simple Blog</h1>'
 
@app.route('/users/<username>')
def show_user_profile(username):
    return f'<h1>User: {username}</h1>'
 
@app.route('/posts/<int:post_id>')
def show_post(post_id):
    # 假设这里有一个获取帖子内容的函数 get_post(post_id)
    post = get_post(post_id)
    return f'<h1>Post {post_id}: {post.title}</h1>'
 
if __name__ == '__main__':
    app.run()

这个简化的代码示例展示了如何在Flask应用中定义一个用户模型并创建数据库。它使用了Flask-SQLAlchemy扩展来简化数据库的操作。在实际应用中，你需要实现数据库的迁移、用户模型的其他方法以及获取帖子内容的函数。

- 阅读更多 -

Spring Boot中的@Scheduled注解：定时任务的原理与实现

System

2024-09-05

所有,java




import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.time.format.DateTimeFormatter;
import java.time.LocalDateTime;
 
@Component
public class ScheduledTasks {
 
    private static final DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("HH:mm:ss");
 
    // 每5秒执行一次
    @Scheduled(fixedRate = 5000)
    public void reportCurrentTime() {
        System.out.println("现在时间是：" + dateTimeFormatter.format(LocalDateTime.now()));
    }
}

这段代码使用了@Scheduled注解来创建一个简单的Spring Boot定时任务。fixedRate = 5000表示任务将以固定频率5秒执行一次。该任务将打印当前的时间戳到控制台。这个例子展示了如何使用@Scheduled来创建一个简单的定时任务，并且如何使用DateTimeFormatter来格式化日期时间输出。

- 阅读更多 -

使用 Llama 3 开源和 Elastic 构建 RAG

System

2024-09-05

所有,AIGC

RAG（Risk Assessment and Governance）是一种风险评估和管理框架，通常用于保障企业安全和合规。以下是使用 Llama 3 开源项目和 Elastic 技术栈来构建 RAG 的一个基本示例：




from llama_3 import Llama3
from elasticsearch import Elasticsearch
 
# 初始化 Llama 3 实例
llama = Llama3()
 
# 初始化 Elasticsearch 客户端
es = Elasticsearch("http://localhost:9200")
 
# 定义 RAG 评估函数
def perform_rag_assessment(entity):
    # 执行 Llama 3 分析
    risk_score = llama.analyze(entity)
 
    # 将评估结果存储到 Elasticsearch
    es.index(index="rag", id=entity, document={"entity": entity, "risk_score": risk_score})
 
    # 根据风险评分确定风险等级
    if 0.0 <= risk_score < 0.25:
        return "GREEN"  # 绿色
    elif 0.25 <= risk_score < 0.50:
        return "AMBER"  # 橙色
    elif 0.50 <= risk_score < 0.75:
        return "RED"  # 红色
    else:
        return "MAGENTA"  # 品红色
 
# 执行 RAG 评估
entity = "example.com"
rag_level = perform_rag_assessment(entity)
print(f"The RAG level for {entity} is {rag_level}")

这段代码展示了如何使用 Llama 3 进行风险评估，并将评估结果存储到 Elasticsearch，然后根据风险评分将实体映射到 RAG 颜色等级。这是一个简化的示例，实际应用中可能需要更复杂的逻辑来处理不同的情况。

- 阅读更多 -

利用Redisson封装一个限流工具并解析限流原理

System

2024-09-05

所有,redis




import redis.clients.jedis.Jedis;
 
public class RateLimiter {
    private final Jedis jedis;
    private final String keyPrefix;
    private final int limit;
    private final int seconds;
 
    public RateLimiter(Jedis jedis, String keyPrefix, int limit, int seconds) {
        this.jedis = jedis;
        this.keyPrefix = keyPrefix;
        this.limit = limit;
        this.seconds = seconds;
    }
 
    public boolean isAllowed(String userId) {
        String key = keyPrefix + ":" + userId;
        long now = System.currentTimeMillis() / 1000;
        long count = jedis.incr(key);
        if (count == 1) {
            jedis.expire(key, seconds); // 如果是第一次访问，设置键的过期时间
        }
        // 如果当前次数超过限制，则不允许访问，并删除该键以便下次重新计数
        if (count > limit) {
            jedis.del(key);
            return false;
        }
        // 如果没有超过限制，则允许访问
        return true;
    }
}

这段代码定义了一个名为RateLimiter的类，它使用Redis的INCR命令来跟踪给定用户ID的请求次数，并在达到限制时删除键。它展示了如何使用Redis来实现简单的限流工具，并且是学习Redis限流机制的一个很好的起点。

- 阅读更多 -

springboot 项目整合 AI (文心一言）

System

2024-09-05

所有,AIGC

要在Spring Boot项目中整合文心一言（Baidu's AI Platform），你需要按照以下步骤操作：

在Spring Boot项目中添加文心一言服务的依赖。
获取文心一言的API Key。
使用RestTemplate或者WebClient来调用文心一言的API。

以下是一个简单的例子，展示如何使用Spring Boot整合文心一言：

步骤1：添加依赖

确保你的pom.xml包含以下依赖（请根据实际情况使用最新版本）：




<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>你的版本号</version>
    <scope>compile</scope>
</dependency>

步骤2：获取API Key

前往百度AI开放平台获取文心一言的API Key。

步骤3：配置文心一言服务的URL和API Key

在application.properties或application.yml中配置文心一言服务的URL和API Key：




ai.baidu.url=https://aip.baidubce.com/rpc/2.0/ai_custom
ai.baidu.apiKey=你的API_Key
ai.baidu.secretKey=你的SECRET_Key

步骤4：创建配置类

创建配置类来读取配置文件中的信息：




@Configuration
@ConfigurationProperties(prefix = "ai.baidu")
@Data
public class AiBaiduConfig {
    private String url;
    private String apiKey;
    private String secretKey;
}

步骤5：创建服务类

创建服务类来调用文心一言的API：




@Service
public class AiBaiduService {
    private final AiBaiduConfig aiBaiduConfig;
    private final RestTemplate restTemplate;
 
    public AiBaiduService(AiBaiduConfig aiBaiduConfig, RestTemplate restTemplate) {
        this.aiBaiduConfig = aiBaiduConfig;
        this.restTemplate = restTemplate;
    }
 
    public String getResponse(String text) {
        // 构建请求体
        MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
        params.add("text", text);
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
        HttpEntity<MultiValueMap<String, String>> requestEntity = new HttpEntity<>(params, headers);
 
        // 发起POST请求
        ResponseEntity<String> response = restTemplate.postForEntity(aiBaiduConfig.getUrl(), requestEntity, String.class);
        return response.getBody();
    }
}

步骤6：使用服务

在你的Controller中使用AiBaiduService：




@RestController
public class AiController {
    private final AiBaiduService aiBaiduService;
 
    public AiController(AiBaiduService aiBaiduService) {
        this.aiBaiduService = aiBaiduService;
    }
 
    @PostMapping("/ask")
    public String ask(@RequestParam String text) {
        return aiBaiduService.getResponse(text);
    }

- 阅读更多 -

spring boot 整合KingbaseES(人大金仓数据库)

System

2024-09-05

所有,java

Spring Boot整合人大金仓数据库（KingbaseES），你需要做以下几个步骤：

在项目的pom.xml中添加人大金仓的JDBC驱动依赖。
配置数据源和JPA或JDBC模板。
创建实体和Repository接口（如果使用Spring Data JPA）。

以下是一个简单的示例：

Step 1: 添加依赖




<!-- 在pom.xml中添加人大金仓数据库驱动依赖 -->
<dependency>
    <groupId>com.kingbase8</groupId>
    <artifactId>kingbase8-jdbc</artifactId>
    <version>你的版本号</version>
</dependency>

Step 2: 配置数据源




// 在application.properties或application.yml中配置数据源
spring.datasource.url=jdbc:kingbase8://localhost:54321/yourdb
spring.datasource.username=youruser
spring.datasource.password=yourpassword
spring.datasource.driver-class-name=com.kingbase8.Driver

Step 3: 配置JPA或JDBC模板




// 使用Spring Data JPA
@Configuration
public class DataConfig {
 
    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
 
    // 如果使用Spring Data JPA
    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory(DataSource dataSource) {
        LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
        em.setDataSource(dataSource);
        em.setPackagesToScan("你的实体包路径");
 
        JpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
        em.setJpaVendorAdapter(vendorAdapter);
        em.setJpaProperties(additionalProperties());
        return em;
    }
 
    Properties additionalProperties() {
        Properties properties = new Properties();
        properties.setProperty("hibernate.hbm2ddl.auto", "update");
        properties.setProperty("hibernate.dialect", "org.hibernate.dialect.KingbaseESDialect");
        return properties;
    }
 
    // 配置事务管理器
    @Bean
    public PlatformTransactionManager transactionManager(EntityManagerFactory emf) {
        return new JpaTransactionManager(emf);
    }
}

Step 4: 创建实体




// 实体类示例
@Entity
@Table(name = "your_table")
public class YourEntity {
    @Id
    private Long id;
    // 其他字段和方法
}

Step 5: Repository接口




// Repository接口示例
public interface YourEntityRepository extends JpaRepository<YourEntity, Long> {
    // 自定义查询方法
}

确保你的实体类和数据库表能够正确映射，并且所有的字段和表关系都通过@Entity, @Table, @Id, @Column等注解正确标注。

这样，你就可以在Spring Boot应用中使用人大金仓数据库了。记得替换示例中的数据库URL、用户名、密码、实体类名和表名等为你自己的配置。

- 阅读更多 -