技术细节

  • 在不同的云厂商,购买相同规格的MySQL实例(如4vCPU-16GB),获得的性能相同吗?

    threads/qpsaliyun_202409_hangzhou->stdbenchtencent_202409_beijing_exclusive->stdbenchhwcloud_202409_beijing_x86->stdbenchbaiducloud_202409_beijing->stdbenchaws_202409_tokyo_m6i->stdbenchazure_202409_east_asia_4c16g->stdbenchgcp_202409_tokyo_80_enterprise->stdbenchoci_202409_tokyo_8039->mysql_on_4_ecpu
    47102559225572206163920257233551
    897029936467441013313365413415936
    161466016141822972986427654825028054
    3222155223361352012022121571036348578317
    4827905247701784916448165161197367458130
    6432704264952011418187181181276180717838
    9636846290772088321007207821330096758504
    128396972991820128210292244613388106208198
    192389993061020521220912259013478115078043
    256383563105221187216652232312985118727907
    384396793122421729211672190212904121318209
    512403333180522647216272159112930121068386
    have_sslDISABLEDDISABLEDDISABLEDDISABLEDYESYESYESYES
    innodb_buffer_pool_size9.75GB12GB9GB12GB11GB12GB11GB17GB
    innodb_doublewriteONONONONOFFOFFONON
    innodb_flush_log_at_trx_commit11111111
    innodb_flush_methodO_DIRECTO_DIRECTO_DIRECTfsyncO_DIRECTfsyncO_DIRECTO_DIRECT
    innodb_io_capacity200002000012000200020020050001250
    innodb_read_io_threads44484NA42
    innodb_write_io_threads44484NA44
    log_binONONONONOFFONONON
    performance_schemaOFFOFFOFFOFFOFFONONON
    rpl_semi_sync_master_enabledONONONONNANANANA
    rpl_semi_sync_master_timeout1000100001000010000NANANANA
    sync_binlog11110001111
    thread_pool_size84NANANA4NA16
    version8.0.368.0.30-txsql8.0.28-2310038.0.32-2.0.0.28.0.358.0.37-azure8.0.31-google8.0.39-cloud
    cpu_capacity80.493.3163.673.9110.956.349.9114.7

    测试结果概述

    在本次测试中:阿里云RDS MySQL性能表现最好,极限的QPS达到了4万;其次是腾讯云,达到了3.2万;第二梯队是华为云、百度云和AWS,极限的QPS约2.2万;之后是Azure、Google云,极限QPS约1.2万;最后是Oracle云,极限QPS约8500。详细的数据和趋势图,可以参考以上的图、表,这里不再详述。

    (more…)
  • 近日,MySQL发布了8.4版本,这是一个新的稳定版。在MySQL版本规划中,在2026年8.0.x生命周期结束后,将成为下一个主流稳定版本。

    目前为止,看到该版本并没有特别大的改进。部分改变包括改进了直方图统计信息更新、并行复制、组复制(GR)等,完整的更新可以参考:Changes in MySQL 8.4.0 (2024-04-30, LTS Release)

    MySQL 8.4@OCI性能测试(vs MySQL 8.0)

    Oracle Cloud上也第一时间支持了该版本,于是也通过性能测试的方式,第一时间“尝鲜”了一下该版本。性能测试的趋势图如下:

    注意到,在该Sysbench测试模式下:

    • 当前MySQL 8.4在性能上相对于8.0版本,要低21%(以16并发为参考)
    • 并在超高并发时(并发高于192),性能出现了严重的退化

    作为一个稳定版本,期待官方尽快解决。

    (more…)
  • 在Oracle Cloud Infrastructure(简称OCI,也就是Oracle云)上购买MySQL实例,也会有第三代CPU和第四代CPU规格的选择,分别是:MySQL.VM.Standard.E4.2.32GBMySQL.VM.Standard.E3.2.32GB。本文对比两个版本规格的价格与性能,以供参考。

    结论概述

    E4(AMD EPYC 7J13)、E3(AMD EPYC 7742)同属于AMD系列的CPU,E4似乎主要是在OCI平台,E3较为通用。从性能测试上,可以看到,E4相比于E3有着较为明显的性能优势,以常见的16并发时数据为参考,则E4(MySQL.VM.Standard.E4.2.32GB)相比于E3(MySQL.VM.Standard.E3.2.32GB)性能要高11%。

    这也与之前的,“新一代CPU总是有着更高的性能”的结论一致。

    (more…)
  • 个人的一些脚本和代码,经常会分散在不同的地方,管理起来并不方便,例如给WordPress编写的Plugin、测试MySQL时使用的一些脚本等,所以打算全部使用GitHub管理起来。对于个人使用,GitHub提供了私人仓库以存储代码,可以较为方便的管理一些还没有公开的个人代码。

    建立个人Git和GitHub环境

    GitHub CLI是一个具体简单交互式操作的命令行,可以完成与GitHub相关的一些交互与操作。对应的软件包/命令是gh

    安装gh-cli

    参考:Installing gh on Linux and BSD。Amazon Linux 2上安装:

    sudo yum-config-manager --add-repo https://cli.github.com/packages/rpm/gh-cli.repo
    sudo yum install gh

    使用gh配置GitHub授权

    接着,就可以使用gh auth login命令来进行GitHub的认证了(gh cli manual)。这是一个简单的交互式命令,这里使用https+token的方式完成认证(也可以使用浏览器的方式辅助完成命令行认证):

    gh auth login
    ? What account do you want to log into? GitHub.com
    ? What is your preferred protocol for Git operations on this host? HTTPS
    ? Authenticate Git with your GitHub credentials? Yes
    ? How would you like to authenticate GitHub CLI? Paste an authentication token
    Tip: you can generate a Personal Access Token here https://github.com/settings/tokens
    The minimum required scopes are 'repo', 'read:org', 'workflow'.
    ? Paste your authentication token: *********************************************************************************************
    - gh config set -h github.com git_protocol https
    ✓ Configured git protocol
    ! Authentication credentials saved in plain text
    ✓ Logged in as orczhou

    关于Token的配置与获取,可以参考:GitHub->Settings->Developer Settings ,这里不再详述。注意,Token意味着分配的所有的仓库权限,必须妥善保管,否则可能会带来巨大的安全隐患。

    如果要登出的话,则可以简单的使用如下命令:

    gh auth logout

    在本地pull与push仓库

    • 首先,在git中配置本地身份(用户名与)
    git config --global user.name "orczhou"
    git config --global user.email "orczhou@orczhou"
    • 首先,新建一个本地模板,并使用git命令初始化
    mkdir  terraform && cd terraform
    git init
    • 配置远端(remote)分支;并拉取远端代码
    git remote add origin https://github.com/orczhou/cloud-mysql-benchmark.git
    git pull origin main

    向远端push代码

    这时,如果修改了仓库中的代码,则可以使用push命令向远端发起提交请求。

    修改、测试并本地提交代码:

    vi gcp_rds_ins/all_in_one/README.md
    git add gcp_rds_ins/all_in_one/README.md
    git commit -m "gcp readme updated"

    向远端push修改:

    git push -u origin main

    该操作会向远端仓库的main分支,提交代码。

    向main分之合并代码

    可以在GitHub仓库页面,对比并创建一个pull request。

    发起pr之后,代码仓库则可以进行merge操作,将代码合并到main分之。

    在新增远程代码库(origin)

    git remote add origin https://github.com/orczhou/testing-delete-repo-if-u-like.git

    将本地代码,提交到远程代码库(origin)的main分支:

    git push -u origin main

    上面的,-u origin main ,其中-u参数表示push的目标代码库-u | --set-upstream

    在现有仓库的main分之上开发

    经常需要做这个动作,常用的命令比较简单,这里记录如下:

    mkdir repo_bench && cd repo_bench
    git init
    git branch -M main
    git remote add origin https://...
    git pull origin main
    
    

    直接修改本地main中的代码并提交到源端:

    cat "..." > README.md
    git add README.md
    git commit -m "first commit" --dry-run
    git commit -m "first commit"
    git push -u origin main

    使用gitignore忽略文件

    在代码开发过程中,由于编译、运行等原因会产生很多的中间文件,而这些中间文件时无需提交到代码仓库的。这时候,需要使用gitignore来忽略这部分文件。详细完整的gitignore的使用可以参考man gitignore

    常用的gitignore是可以通过.gitignore文件来实现,即在代码的根目录中新建该文件,那么在代码处理时,就会根据根据该文件的规则进行忽略。例如Terraform脚本常用的gitignore文件可以参考:

    所以,一个Terraform脚本的.gitignore可以依次作参考:

    # Compiled files
    *.tfstate
    *.tfstate.backup
    *.tfstate.lock.info
    
    # Directories
    .terraform/
    .vagrant/
    
    # SSH Keys
    *.pem
    
    # Ignored Terraform files
    *gitignore*.tf

    master分支与main分支

    在搜索git/github的相关资料的时候,经常还会搜索到master分支作为主分支的资料或者仓库。在2020年的George Floyd的案件发生后,美国的Black_Lives_Matter运动达到了前所未有的高度,最终也影响到在计算机领域的master/slave 一词的使用。更多的参考:Renaming the default branch from master@GitHubWhy GitHub renamed its master branch to main@theserverside

    不过,git在本地默认还是使用默认的master分支,所以如果没有手动切换分支,则还是会经常“默认的”创建master分支。

    查看未提交的修改

    git面向的场景就是分布式、多任务的开发代码管理,其独特的”three tree“模型可以很巧妙的实现这些能力。这也给初学者带来了很多理解上的障碍。

    git diffgit diff HEAD

    如果,想要查看自上次commit以来的所有变更,则需要试用git diff HEAD命令,通常HEAD指向的是,最后一次commit时的位置。

    git diff 工作区 vs 暂存区

    git diff –cached 暂存区 vs 版本库

    同步远程更新

    个人代码仓库管理中,有时候会有这样的情况:直接在远程仓库中修改了一些文件,然后如何让本地和远程保持同步。考虑这样的场景:直接在GitHub上对README.md文件进行了编辑,那么本地代码仓库如何保持这个更新。

    当然,这样做,通常可能会很危险:可能会覆盖掉你本地所做的更改,但是基于上面的场景,所以,有时候会需要这么做。Stackoverflow上有几个相关的问题,非常详细的介绍了做法:

    这里的推荐做法是这样,如果本地仓库的修改确定不要了(通常这是很危险的):

    git pull

    如果本地仓库修改都还需要:

    git stash
    git pull 
    git stash pop

    还可以:

    • 先使用 git fetch更新origin/main
    • 然后使用git diff main origin/main查看本地与远程的差异
    • 最后使用git mergeorigin/main与本地合并,并保持在本地

    这样origin/main是最新的,且本地分支也是最新的了

    git fetch
    git diff main origin/main
    git merge

    参考链接

  • 引言

    这是一个系列文章,旨在了解如何使用Flex/Lex和Yacc/Bison进行词法和语法解析。在前面,已经完成了使用Lex/flex做基础的词法解析实现一个简单的计算器。开始这个系列的第三部分,使用flex和bison完成一个更加复杂的的编译程序。整体上有一定的复杂度,所以分上下篇分别介绍。上篇介绍:实现概要、语法、,下篇介绍数据结构与实现(包括解析树实现、执行)。

    • 下篇介绍:数据结构与实现
      • 与Grammar对应的“解析树”
      • “解析树”的执行
      • 解析树的节点,Terminals 和 Non-Terminals
      • 一个“简单语句”的解析树结构
      • 一个“略微复杂语句”的解析树结构

    解析与执行包含赋值、IF、WHILE等语句的程序

    在前面的案例中,我们实现了一个简单的加减乘运算的计算器程序。这里我们尝试实现一个更复杂一些的编译程序,语法能够支持如下内容:

    • 包含了变量,可以对变量赋值,也可以在表达式中使用变量。但是为了简化程序,这里变量仅限于使用单个小写字母,即[a-z]
    • 支持条件运算,这里定义简单的语法如下:if ( expr ) expre ; (忽略了else语法)
    • 支持比较运算符,包括大于、小于
    • 支持循环运算,支持while循环
    • 和前面案例的一样,仅处理整数,故不处理除法,也不考虑整数溢出等边界问题

    我们用这几个能力,可以编写如下的程序:

    i = 1;
    a = 0;
    while ( a < 100 ) {
      i = i + 1;
      a = a + i;
    }
    print i;

    这个程序实现了一个简单的功能,解决的问题是:在自然数序列(1、2、4…)中,前面多少个自然数的和首次大于100。你可以使用上面的命令编写其他的任意程序。

    解析树的节点

    如果只是使用前面的指令,似乎难以实现对if/while语句的支持。这里,就需要使用典型的编译与执行思路了,先使用语法解析构建一个“语法树”(也叫“解析树”),然后再执行该解析树。具体的,一些设计如下:

    • 使用一个全局数组(int * var[26])存储变量,因为在前面限制了变量名只能是[a-z]
    • 每个grammar rule对应一个tree node,并依次构建一棵语法树
    • 语法树的节点设计如下:
    typedef struct t_node{
        enum NODETYPE nt;
        struct t_node* left;
        struct t_node* right;
        int i;  // for NT_INTEGER NT_VAR_NAME node
    }t_node;

    这里为了简化:

    • 所有语法节点都存放在该结构中
    • 对于变量名,本应该是一个字符,这里在存储时,直接使用其ASCII码将其存储为整数

    语法规则设计

    在开始实现与执行解析树之前,我们先定义语法规则,以支持赋值、if、while、print等语法。语法规则定义时,需要注意尽量避免出现shift/reduce冲突,并且这里的语法规则不包含Action部分:

    //start symbol
    program: 
            | program statement_block   { printf("\n job done! \n"); }
    ;
    
    statement_block: 
            | statement_block statement
    ;
    
    statement: assignment
            | print_func
            | if_block
            | while_block 
    ;
    
    while_block: WHILE '('  bool_expr ')' '{' statement_block '}'
    
    if_block: IF '(' bool_expr ')' '{' statement_block '}'
    
    assignment: VAR_NAME '=' expression ';'
    
    print_func : PRINT expression ';'  
            | PRINT VAR_NAME ';'
    
    bool_expr: expression GT expression
            |  expression LT expression
    
    expression: INTEGER
            | VAR_NAME
            | expression O_ADD expression
            | expression O_MINUS expression
            | expression O_MULTIPLY expression

    节点分析

    节点分析:INTEGER VAR_NAME
    • 节点类型(enum NODETYPE)分别是:NT_INTEGER NT_VAR_NAME
    • 没有子节点,故left/right node都是NULL
    • 在初始化时,
      • 对于INTEGER:t_node.a 存储的是具体的整数
      • 对于VAR_NAME:则存储的变量名,这了变量名为[a-z],则将其ASCII存放于t_node.a

    节点分析:expression 与 O_ADD O_MINUS O_MULTIPLY

    expression对应的语法规则如下

    expression: INTEGER
            | VAR_NAME
            | expression O_ADD expression
            | expression O_MINUS expression
            | expression O_MULTIPLY expression

    那么,再看看O_ADD O_MINUS O_MULTIPLY这类节点:

    • NODETYPE 分别是 NT_O_ADD NT_O_MINUS NT_O_MULTIPLY
    • 都有两个子节点,left / right
    • 在execute之后存储,各个expression计算的结果值t_node.a
    • 注意,在这个设计中,无需有一个独立的expression节点

    bool表达式(bool_expr),通常用于条件判断

    bool_expr: expression GT expression 
            |  expression LT expression 
    • 节点类型(enum NODETYPE)为 NT_BOOL_EXPR
    • 有两个子节点,执行该节点时,需要执行两个子节点之后,获得两个子节点的结果值,再进行比较
    • 返回值为为bool型,这里使用int存储,0表示FALSE 1表示TRUE

    print_func节点

    这个节点实现一个打印整数值的功能,参数可以是一个变量,也可以是一个表达式:

    print_func : PRINT expression ';'  
            | PRINT VAR_NAME ';' 
    • NODETYPENT_PRINT_FUNC
    • 只有一个子节点,为一个 expression 或 VAR_NAME (注:这里应该只用expression就可以了,因为VAR_NAME也是expression)
    • 执行该节点时,则需要实际调用一次打印函数,向标准输出打印expression的结果值

    assignment 赋值语句

    assignment: VAR_NAME '=' expression ';'

    赋值语句左边是变量名,这里定义是[a-z],右边是一个表达式,语句以分号结束。

    • 其节点类型(NODETYPE)为:NT_ASSIGNMENT
    • 左子节点为 VAR_NAME ,右子节点为 expression
    • 其执行时,需要将expression的结果值,存储到变量数组对应的整型变量中

    while_block WHILE子句

    while_block: WHILE '('  bool_expr ')' '{' statement_block '}'
    • 其节点类型(NODETYPE)为:NT_WHILE
    • 左子节点为: bool_expr 右子节点为 : statement_block
    • 执行该节点时,也是也while循环执行,条件部分是执行并判断bool_expr的真假,再决定是否执行右子节点。这里需要注意,每次获取bool_expr的时候,都需要先执行一次该节点。

    if_block IF子句

    if_block: IF '(' bool_expr ')' '{' statement_block '}'
    • 其节点类型(NODETYPE)为:NT_IF
    • 左子结点为 bool_expr 右子节点 : statement_block
    • 执行时,先执行左子节点,再获取其结果的真/假,再判断是否执行右子节点

    statement

    statement: assignment
            | print_func
            | if_block
            | while_block

    可以看到,statement由assignment、print_func、if_block、while_block是这些中的任何一个。所以,在实际构建中,并不会有该节点。与expression类似。

    statement_block 多个statement

    statement_block: 
            | statement_block statement
    ;
    • 其节点类型(NODETYPE)为:NT_STATEMENT_BLOCK
    • 左子节点为 : statement_block,即为statement_block或者assignment、print_func、if_block、while_block中的任意一个;右子节点为 : assignment、print_func、if_block、while_block
    • 执行时,先执行左子节点,再执行右子节点

    program

    program:
            | program statement_block  { printf("\n job done! \n"); }
    ;

    主要的数据结构与函数

    • build_node:构建当前语法规则的节点,该函数返回当前构建出来节点的指针,通常也是各个语法规则Action部分的返回值。
    t_node* build_node( 
        enum NODETYPE nt,
        t_node* left,
        t_node* right,
        int i)
    • exec_node:执行某个节点,并执行其左/右子节点(如果存在的话)。不同的节点的执行操作会有一些不同,例如:
      • if节点需要做一些判断,再决定是否执行;
      • while节点则需要循环bool_expr以决定是否执行某段代码。
      • 加法节点,则需要执行左右子节点执行结果,并相加

    各类节点的exec操作可以参考上一节的详细描述。该函数定义如下

    int exec_node(t_node *n)
    • 解析树的节点与节点类型
    typedef struct t_node{
        enum NODETYPE nt;
        struct t_node* left;
        struct t_node* right;
        struct t_node* rrnode;
        int i;  // for NT_INTEGER NT_VAR_NAME node
    }t_node;
    enum NODETYPE{
        NT_STATEMENT,
        NT_IF,
        NT_WHILE,
        NT_PROGRAM,
        NT_STATEMENT_BLOCK,
        NT_O_ADD,
        NT_O_MINUS,
        NT_O_MULTIPLY,
        NT_INTEGER,
        NT_VAR_NAME,
        NT_BOOL_EXPR_GT,
        NT_BOOL_EXPR_LT,
        NT_PRINT,
        NT_ASSIGNMENT
    };

    下一篇,我们将基于此完成完整的代码。

    不包含Action代码的语法

    补充完整的语法文件cal.y

    包括:

    • 入口函数
    • NODETYPE 定义
    • 解析树的节点 t_node
    • 声明节点便利函数 exec_node
    • 用于存储变量的数组 int var[26];
    • YYSTYPE (似乎是不需要)
    • 定义lex需要处理的TOKEN
    • 定义运算符优先级、结合律
    %{
    // 入口函数
    
    #include <stdio.h>
    
    int main (){
        yyparse();
        return 0;
    }
    
    enum NODETYPE{
        NT_PROGRAM,
        NT_STATEMENT_BLOCK,
        NT_STATEMENT,
        NT_IF,
        NT_WHILE,
        NT_O_ADD, 
        NT_O_MINUS,
        NT_O_MULTIPLY,
        NT_INTEGER,
        NT_VAR_NAME
    };
    
    typedef struct t_node{
        enum NODETYPEP nt;
        t_node * left;
        t_node * right;
        t_node * rrnode;
        YYSTYPE yval;
    }t_node;
    
    //递归执行整个parser tree
    int exec_node(t_node *n){
        return 0;
    }
    
    int var[26];
    
    %}
    
    // 定义YYSTYPE
    %union {
        int a;  // for integer
        char c; // for var_name
        bool b; // for bool_expr
    }
    
    
    // 定义Token
    %token <c> VAR_NAME 
    %token <a> INTEGER
    %token O_ADD O_MINUS O_MULTIPLY 
    
    %token GT LT
    
    %token WHILE IF
    %token PRINT
    
    // 定义运算符
    %left O_ADD O_MINUS
    %left O_MULTIPLY
    

    补充Lex文件

    %{
        #include "cal.tab.h"
    %}
    %option noyywrap
    %%
    [[:digit:]]+ {
        yylval.a = atoi(yytext);
        return INTEGER;
    }
    
    [a-z] {
        yylval.c = yytext[0];
        return VAR_NAME;
    }
    
    "+" { return O_ADD;};
    "-" { return O_MINUS;};
    "*" { return O_MULTIPLY;};
    
    "while"  {return WHILE;}
    "if"  {return IF;}
    "print"  {return PRINT;}
    
    ">" {return GT;}
    "<" {return LT;}
    
    [();={}]  {return yylval.c = *yytext;}
    
    %%

    生成代码并编译、修改

    lex cal.l 
    bison -d cal.y 
    gcc cal.tab.c lex.yy.c -o a.out
    
    
    bison -W -d cal.y
    
    cal.y:62.8: warning: empty rule without %empty [-Wempty-rule]
     program:
            ^
    cal.y:66.16: warning: empty rule without %empty [-Wempty-rule]
     statement_block:
                    ^
    cal.y: warning: 6 shift/reduce conflicts [-Wconflicts-sr]

    错误1:这里的 PRINT expression ‘;’ PRINT VAR_NAME ‘;’ 是有包含关系,重复的。因为VAR_NAME本身也是一个expression。故修改如下:

    print_func : PRINT expression ';'  
            | PRINT VAR_NAME ';' 
    
    expression: INTEGER
            | VAR_NAME
            | expression O_ADD expression
            | expression O_MINUS expression
            | expression O_MULTIPLY expression

    疑问与思考:左边/右边的表达有什么不同。(注意,左边的表达会报shift/reduce conflict)

    program: 
            | program statement_block 
    ;
    
    statement_block: 
            | statement_block statement
    ;
    
    statement: assignment
            | print_func
            | if_block
            | while_block 
    ;
    program: statement_block 
    ;
    
    
    statement_block:
            | statement_block statement
    ;
    
    statement: assignment 
            | print_func 
            | if_block 
            | while_block 
    ;

    修改后的cal.y文件,仅语法部分,不包含Action

    %%
    program:  statement_block { printf("\n job done! \n");}
    ;
    
    statement_block:
            | statement_block statement
    ;
    
    statement: assignment 
            | print_func 
            | if_block 
            | while_block 
    ;
    
    if_block: IF '(' bool_expr ')' '{' statement_block '}' 
    
    while_block: WHILE '('  bool_expr ')' '{' statement_block '}' 
    
    assignment: VAR_NAME '=' expression ';'
    
    print_func : PRINT expression ';'
    
    bool_expr: expression GT expression
            |  expression LT expression
    
    expression: INTEGER
            | VAR_NAME
            | expression O_ADD expression
            | expression O_MINUS expression
            | expression O_MULTIPLY expression
    
    

  • MySQL在上个月正式EOL,意味着官方不会再发布新版本去修复Bug或者安全漏洞。一般来说,云厂商对老版本支持要更就一些,那么一起来看看各个云厂商对5.7的支持情况。概述:

    • AWS:首先,AWS RDS MySQL将提供额外的、免费的半年标准支持,期间提供bug修复、漏洞修复等;2024年2月后,AWS RDS将提供付费的扩展支持。届时,如果不选择付费扩展支持的实例,将会自动(可以理解为“强制”)被升级到8.0版本,“付费”的扩展支持应该持续3年。(注:Aurora的免费支持时间会更长一些,到2024年11月)
    • 阿里云:目前,对于5.7还没有看到正式的说明。但,对于5.6版本,阿里云数据库曾发通告,将提供额外的三年维护时间。不过鉴于5.7实例体量巨大(因为8.0版本拖的时间太长),对于5.7版本支持的时间可能会更长。
    • 其他云厂商:目前都比较模糊,可以理解为不会有任何动作,用户可以正常使用。

    AWS对MySQL 5.7的支持

    AWS有Aurora MySQL 5.7(即Aurora 2.x系列)、RDS MySQL 5.7两个版本。在Oracle MySQL官方到达EOL后,AWS额外提供了半年(Aurora约一年)的免费标准支持,以及三年的付费支持。即,AWS RDS将免费支持5.7到2024年02月底,Aurora到2024年11月底;另外,还将提供三年的付费支持,约到2027年。是的,要收费的(参考)。这段时间,AWS将继续提供安全相关的Bug修复、以及重要的功能Bug修复。

    这个收费策略应该是开了云厂商对于旧版本数据库支持的先河。维护老的版本,需要额外的技术人员投入,维护一个过期的版本的投入从长时间来看,是低效的,所以,用户是需要为这部分服务付费的。

    AWS 扩展支持的收费方式与费率

    收费方式是按照vCPU * HourACU * Hour计费,不同的区域会有不同,不同的时间也会不同,离官方EOL时间越长,费用会越贵。不过,在官方版本到达EOL之后,AWS预留了4个月~一年的免费时间,让用户安排升级。以RDS MySQL 5.7为例,自2024年2月底之后,以新加坡地区为例,前两年付费扩展支持价格为 $0.12/(vCPU * Hour),第三年的费用为$0.24/(vCPU * Hour)。以一个4c16g(db.m5.xlarge)的实例计算,一个月费扩展支持费用约为$345。而该实例本身的价格约为(两节点高可用):$677 = 0.47*24*30*2。所以,AWS的策略是,价格摆在这里了,升不升级,由用户自己定夺。

    (more…)