Redis persistence - detailed analysis of RDB source code ｜ nanny level analysis! The most complete network

One 、 background

Redis  The persistence of data is mainly through  RDB  and  AOF  Two ways , among  AOF  It can be mixed persistence , That is, there is  AOF  and  RDB  The contents of the two agreements ;

RDB  Essentially, redis Memory snapshot at a certain moment ,

AOF  Then the data is added and saved according to the data disk brushing strategy ;

therefore ,RDB Yes, fast generation 、 Data file size 、 The advantage of fast recovery , But data is just a snapshot of a certain moment ,AOF  Save all data , High timeliness , Advantages saved according to the configuration policy , But the disadvantage of relatively slow recovery .

This paper mainly analyzes about  RDB 

And the code flow of file generation , And simple analysis  RDB  agreement , This article is based on redis 5.0.14  Version code for analysis .

Two 、fork()  function   And  Copy On Write

2.1fork()  function

c  In language  fork()  Function creates a child process for the current process through system call , And allocate independent code space and data space to child processes ,

And copy part of the data content to the new data space, and add the sub process to the system process list , Theoretically, a subprocess can do all the next operations of the current process （ You can make the current process and child process do different things through initial parameters or passed in variables ）

fork()  After the function is called, it may return the following three values ,

in other words  fork()  The value returned to the current process after the function call is successful is fork Process of outgoing process id, What is returned to its own process is  0, in other words fork() After the function call succeeds, there will be two return values ：

● Less than 0： Failed to create child process

● be equal to 0： For newly created child processes , The return value is  0

● Subprocesses pid： The current process returns child processes id

2.2Copy On Write

Copy On Write  Also known as copy on write ,

fork()  The underlying implementation of the function adopts this technology （COW）, When a child process is created , The memory mapped by the virtual address space of the child process is the same as the physical memory space of the parent process ;

When the contents of physical memory need to be changed （ A memory page ） The changed memory pages will be copied to the physical memory of the child process first , Then change , In this way , To avoid the fork It takes a lot of memory and consumes a long time .

The following code flow and redis  in RDB The process is similar to ,if  In conditional judgment fork() When the function is completed, there are already sub processes , According to the child process of the process pid  To determine the logical branch that should be executed , So in if Branches are executed by child processes , and else Branches are executed by the current process ,count  Can be understood as in RDB In the process redis  Actual content stored ,count The initial value of is the same in the current process and child processes ;

Therefore, when the child process calls the function first to change the value, it needs to set count For copying physical memory pages to the actual physical space of child processes , Then change the value stored in the physical space of the child process ,

At this time, in the current process count The value has not changed , The communication between the current process and the child process is through pipe To achieve .

3、 ... and 、redis RDB  Data that may be used in the process

redisServer  The structure is redis One of the most important and core data structures in , It contains a large number of runtime States 、 Statistics and other relevant information , The following will cover rdb The content of is picked out and analyzed , Facilitate the subsequent understanding of the code flow .

struct redisServer {
 ...
 // rdb  In the process  COW  Consume d Memory size
 size_t stat_rdb_cow_bytes; /* Copy on write bytes during RDB saving. */
 //  The last time  rdb  End to this rdb  The number of key value pairs changed at the beginning
 long long dirty; /* Changes to DB from the last save */
 //  perform  bgsave  The process of the process id
 pid_t rdb_child_pid; /* PID of RDB saving child */
 // save  Parameter saved rdb  Generation strategy
 struct saveparam *saveparams; /* Save points array for RDB */
 // save  Number of parameters
 int saveparamslen; /* Number of saving points */
 // rdb  File name
 char *rdb_filename; /* Name of RDB file */
 //  Whether the rdb File compression  LZF  Algorithm
 int rdb_compression; /* Use compression in RDB? */
 //  Whether to carry out rdb  Check the file
 int rdb_checksum; /* Use RDB checksum? */
 //  Last time save Time to succeed
 time_t lastsave; /* Unix time of last successful save */
 //  Last attempt to execute bgsave Time for
 time_t lastbgsave_try; /* Unix time of last attempted bgsave */
 //  Last execution bgsave Time spent
 time_t rdb_save_time_last; /* Time used by last RDB save run. */
 //  What is currently being implemented rdb Starting time
 time_t rdb_save_time_start; /* Current RDB save start time. */
 // bgsav  Scheduling status , by 1 Only when bgsave
 int rdb_bgsave_scheduled; /* BGSAVE when possible if true. */
 // rdb  Execution type , Local rdb Persistence or through socket Send out
 int rdb_child_type; /* Type of save by active child. */
 //  Last execution bgsav The state of
 int lastbgsave_status; /* C_OK or C_ERR */
 //  If the last time bgsave Failure , increase redis Data writing is no longer supported
 int stop_writes_on_bgsave_err; /* Don't allow writes if can't BGSAVE */
 ...
};

saveparam  Structure is mainly used to save  save  Set the value of the , It can be set into multiple groups as needed , The default is three groups

struct saveparam {
 time_t seconds; //  Number of seconds
 int changes; //  Number of changes
};

Four 、redis  in  RDB  Code execution process

The following figure for redis It involves generating RDB Diagram of correspondence between commands and background functions ;

shutdown、flushall、save、bgsave、replicaof、redis Timed tasks will trigger redis Persistent operation of , One of the most important and frequently implemented is bgsave, The execution frequency of other commands is relatively low , And the logic code they call at the bottom is basically the same , The big difference is from using the library to copying without disk , This paper mainly analyzes about redis The persistence of , So the following code is mainly for bgsave Analyze ;

bgsave  The main execution process of ：

rdbSaveBackground -> rdbSave -> rdbSaveRio ->  rename

5、 ... and 、redis  In the relevant RDB Parameters and their interpretation

The following parameters are in  redis.conf  To configure , These parameters will affect  rdb  File generation ;

save  Parameter is  redis  Trigger rdb Persistent strategy , It means how many key value pairs have been written in how many seconds since the last persistence ,save ""  It means closing rdb Persistence strategy ,save  Policies can be configured with multiple groups , The default is three groups ：

save 900 1 、save 300 10 、save 60 10000;stop-writes-on-bgsave-error  The default is enabled , Said if rdb Persistence fails redis In read-only state ;

rdbcompression  Representative adoption  LZF  Algorithm compression rdb Key value pairs in ;

rdbchecksum  Generate rdb Or load rdb Check the file when ;

dbfilename  Generated rdb name ;

dir  For storage rdb File directory ;

bgsave_cpulist bgsave  Child processes are preferred cpu Serial number ;

latency-monitor-threshold Unit is ms, Set to 0 Hour means close , When on, record the command whose delay exceeds the configured value

• save <seconds> <changes>

• stop-writes-on-bgsave-error yes

• rdbcompression yes

• rdbchecksum yes

• dbfilename dump.rdb

• dir ./

• bgsave_cpulist 1,10-11

• latency-monitor-threshold 0

6、 ... and 、RDB  Main executive function

rdbSaveBackground  Call in function  fork()  Generate subprocesses , Call through subprocess rdbSave Function to do rdb Persistent operation of , The main process is in fork Record the statistics after completion 、 Logging and setting are disabled rehash Then continue to provide services ,

Need to pay attention to when , Although it is disabled at this time rehash, rehahs  It may still be triggered , The default load factor exceeds 5 when 【 Key value pairs and  buckets  More than 5】

//  Macro definition   Return value
#define C_OK 0
#define C_ERR -1
int rdbSaveBackground(char *filename, rdbSaveInfo *rsi) {
 pid_t childpid; //  Subprocesses   process id
 long long start; // fork  The corresponding microsecond value at the beginning
 //  If it already exists  aof  perhaps  rdb  Subprocesses   Then stop this rdb operation
 if (server.aof_child_pid != -1 || server.rdb_child_pid != -1) return C_ERR;
 //  Last time  rdb  From the beginning to this rdb At the beginning of the   The number of changes of key value pairs
 server.dirty_before_bgsave = server.dirty;
 server.lastbgsave_try = time(NULL); //  take   Last try dbsave The time of is set to the current timestamp  
 openChildInfoPipe(); //  Open process communication between the current process and child processes
 start = ustime(); //  Record fork  Starting time
 // if  The conditional expression passes fork  Turn on   Subprocesses , here   The current process and subprocess start different work contents , Subprocess on rdb, While the current process will normally provide external services after completing some statistical information
 //  Non blocking means  rdb  The process does not block the main process , however   From the beginning fork To fork Completion of this period of time is still blocked
 if ((childpid = fork()) == 0) {
 int retval;
 /* Child */
 closeClildUnusedResourceAfterFork(); //  Close the unnecessary resources inherited from the parent process by the child process
 redisSetProcTitle("redis-rdb-bgsave"); //  Set the name of the child process
 retval = rdbSave(filename,rsi); //  take redis  Save content to   On disk   formation rdb  file
 // rdb  After the file is saved   Yes  rdb  Calculate the resource consumption in the process
 if (retval == C_OK) {
 size_t private_dirty = zmalloc_get_private_dirty(-1);
 // COW  Memory consumed
 if (private_dirty) {
 serverLog(LL_NOTICE,
 "RDB: %zu MB of memory used by copy-on-write",
 private_dirty/(1024*1024));
 }
 server.child_info_data.cow_size = private_dirty;
 sendChildInfo(CHILD_INFO_TYPE_RDB); //  The subprocess  COW  Data is sent to the parent process
 }
 exitFromChild((retval == C_OK) ? 0 : 1);//  close   Subprocesses , This is the end of the work of the subprocess
 } else { //  The current process continues to run , The subprocess goes on rdb operation
 /* Parent */
 server.stat_fork_time = ustime()-start; // fork  The number of microseconds the function takes
 // fork  rate  GB/s
 server.stat_fork_rate = (double) zmalloc_used_memory() * 1000000 / server.stat_fork_time / (1024*1024*1024); /* GB per second. */
 //  And  redis  In the configuration file  latency-monitor-threshold  Parameters related , If the configured value is exceeded , Record the delay caused by this operation
 latencyAddSampleIfNeeded("fork",server.stat_fork_time/1000);
 if (childpid == -1) { //  Subprocesses   Generate failure , Update statistics about bgsave Status and print error log
 closeChildInfoPipe();
 server.lastbgsave_status = C_ERR;
 serverLog(LL_WARNING,"Can't save in background: fork: %s",
 strerror(errno));
 return C_ERR;
 }
 serverLog(LL_NOTICE,"Background saving started by pid %d",childpid);
 server.rdb_save_time_start = time(NULL); //  Record bgsave  Starting time
 server.rdb_child_pid = childpid; //  perform rdb Can be inherited by child processes. id
 server.rdb_child_type = RDB_CHILD_TYPE_DISK; // rdb  The file is saved on disk
 updateDictResizePolicy(); //  prohibit rehash operation
 return C_OK;
 }
 return C_OK; /* unreached */
}

rdbSave  Function mainly generates temporary rdb File and initialize rio File object ,

And then call rdbSaveRio Function to complete rdb Writing files , Last call rename Function atom substitution rdb Temporary file name and rdb The file name set in the configuration

/* Save the DB on disk. Return C_ERR on error, C_OK on success. */
int rdbSave(char *filename, rdbSaveInfo *rsi) {
 char tmpfile[256]; //  Definition  rdb  Temporary file name
 char cwd[MAXPATHLEN]; /* Current working dir path for error messages. */
 FILE *fp;
 rio rdb;
 int error = 0;
 //  Generate rdb Temporary file name ,"temp-" As before ",".rdb" As a suffix , Processes with child processes in the middle id
 snprintf(tmpfile,256,"temp-%d.rdb", (int) getpid());
 fp = fopen(tmpfile,"w"); //  Set the file mode to writable
 if (!fp) { // rdb  Failed to open temporary file
 char *cwdp = getcwd(cwd,MAXPATHLEN); //  Get absolute path
 serverLog(LL_WARNING,
 "Failed opening the RDB file %s (in server root dir %s) "
 "for saving: %s",
 filename,
 cwdp ? cwdp : "unknown",
 strerror(errno));
 return C_ERR;//  return  -1
 }
 //  initialization   File object IO ;rio  yes  redis  In the abstract IO layer , Realized   buffer 、 file io and socket io, The subsequent reading and writing of documents are passed rio Realization
 rioInitWithFile(&rdb,fp);
 if (server.rdb_save_incremental_fsync) //  Determine whether increment is enabled  rdb
 rioSetAutoSync(&rdb,REDIS_AUTOSYNC_BYTES);//  The buffer size is set to  32MB, Write when it exceeds rdb file
 //  take redis  Save content to rdb In file
 if (rdbSaveRio(&rdb,&error,RDB_SAVE_NONE,rsi) == C_ERR) {
 errno = error;
 goto werr;
 }
 /* Make sure data will not remain on the OS's output buffers */
 //  Refresh buffer
 if (fflush(fp) == EOF) goto werr; 
 if (fsync(fileno(fp)) == -1) goto werr; 
 if (fclose(fp) == EOF) goto werr;
 /* Use RENAME to make sure the DB file is changed atomically only
 * if the generate DB file is ok. */
 //  Will be temporary rdb  The file is changed to that configured in the configuration file rdb name , If it fails, record the log and delete the temporary rdb file
 if (rename(tmpfile,filename) == -1) {
 char *cwdp = getcwd(cwd,MAXPATHLEN);
 serverLog(LL_WARNING,
 "Error moving temp DB file %s on the final "
 "destination %s (in server root dir %s): %s",
 tmpfile,
 filename,
 cwdp ? cwdp : "unknown",
 strerror(errno));
 unlink(tmpfile);
 return C_ERR;
 }
 serverLog(LL_NOTICE,"DB saved on disk");
 server.dirty = 0; // rdb  complete , Set the number of change key value pairs at this time to  0 , Start counting again
 server.lastsave = time(NULL); //  Record this time rdb Completion time
 server.lastbgsave_status = C_OK; //  Record this time rdb Completion status
 return C_OK;
werr:
 serverLog(LL_WARNING,"Write error saving DB on disk: %s", strerror(errno));
 fclose(fp);
 unlink(tmpfile);
 return C_ERR;
}

rdbSaveRio The main function of the function is from redis Get all key value pairs in , And in accordance with the rdb The file protocol writes the contents to rdb In file ;

Among them, data is mainly obtained through  dictNext  Function implementation ,rdb  The document protocol is encapsulated in  rio  In the object

int rdbSaveRio(rio *rdb, int *error, int flags, rdbSaveInfo *rsi) {
 dictIterator *di = NULL; //  Define a dictionary iterator , Follow up from redis Read all key value pairs in
 dictEntry *de; //  Every key value pair is saved in  dictEntry  in
 char magic[10]; // rdb  Fixed setting at the beginning of the file  ”REDIS“  Add a rdb The corresponding version number
 int j;
 uint64_t cksum;
 size_t processed = 0;
 if (server.rdb_checksum)
 rdb->update_cksum = rioGenericUpdateChecksum; //  Set the inspection function
 snprintf(magic,sizeof(magic),"REDIS%04d",RDB_VERSION);
 if (rdbWriteRaw(rdb,magic,9) == -1) goto werr; //  take  magic  Write to  rio in
 if (rdbSaveInfoAuxFields(rdb,flags,rsi) == -1) goto werr; /* Save a few default AUX fields with information about the RDB generated. */
 /* Iterate over modules, and trigger rdb aux saving for the ones modules types
 * who asked for it. */ 
 if (rdbSaveModulesAux(rdb, REDISMODULE_AUX_BEFORE_RDB) == -1) goto werr; 
 for (j = 0; j < server.dbnum; j++) { //  Traverse redis All of the  db , Default configuration is  16 individual
 redisDb *db = server.db+j;
 dict *d = db->dict; //  Get  redis in hash  The location of the table ,ht[0] ht[1]
 if (dictSize(d) == 0) continue; //  If hash There are no key value pairs in the table   skip
 di = dictGetSafeIterator(d); //  For the dictionary e Generate a secure iterator
 /* Write the SELECT DB opcode */
 //  Write the database selection identification code ,254 ; stay rdb In file  254  Express   Execution is select DB  operation
 if (rdbSaveType(rdb,RDB_OPCODE_SELECTDB) == -1) goto werr;
 if (rdbSaveLen(rdb,j) == -1) goto werr; //  because db Small total , therefore   Use the low in a byte  6  To said db Count , high 2 Bits represent types
 /* Write the RESIZE DB opcode. We trim the size to UINT32_MAX, which
 * is currently the largest type we are able to represent in RDB sizes.
 * However this does not limit the actual size of the DB to load since
 * these sizes are just hints to resize the hash tables. */
 uint64_t db_size, expires_size;
 db_size = dictSize(db->dict);//  At present db The total number of key value pairs in
 expires_size = dictSize(db->expires); //  At present db The total number of key value pairs with expiration time set in
 if (rdbSaveType(rdb,RDB_OPCODE_RESIZEDB) == -1) goto werr;
 if (rdbSaveLen(rdb,db_size) == -1) goto werr;
 if (rdbSaveLen(rdb,expires_size) == -1) goto werr;
 /* Iterate this DB writing every entry */
 while((de = dictNext(di)) != NULL) {// dictNext  Function traverses all of  buckets,bucket  The key value pairs stored in are stored in the form of a single linked list
 sds keystr = dictGetKey(de); //  obtain  key
 robj key, *o = dictGetVal(de); //  obtain value
 long long expire;
 initStaticStringObject(key,keystr);//  Will get key  Save it in the stack  ？avoid bugs like bug #85 ？
 expire = getExpire(db,&key); //  Get expiration time
 if (rdbSaveKeyValuePair(rdb,&key,o,expire) == -1) goto werr; //  Will be complete  key 、value 、  The expiration time is written rio object
 /* When this RDB is produced as part of an AOF rewrite, move
 * accumulated diff from parent to child while rewriting in
 * order to have a smaller final write. */
 // aof  Mixed persistence is used
 if (flags & RDB_SAVE_AOF_PREAMBLE &&
 rdb->processed_bytes > processed+AOF_READ_DIFF_INTERVAL_BYTES)
 {
 processed = rdb->processed_bytes;
 aofReadDiffFromParent();
 }
 }
 dictReleaseIterator(di);
 di = NULL; /* So that we don't release it again on error. */
 }
 /* If we are storing the replication information on disk, persist
 * the script cache as well: on successful PSYNC after a restart, we need
 * to be able to process any EVALSHA inside the replication backlog the
 * master will send us. */ 
 //  preservation  lua  Script
 if (rsi && dictSize(server.lua_scripts)) {
 di = dictGetIterator(server.lua_scripts);
 while((de = dictNext(di)) != NULL) {
 robj *body = dictGetVal(de);
 if (rdbSaveAuxField(rdb,&quot;lua&quot;,3,body->ptr,sdslen(body->ptr)) == -1)
 goto werr;
 }
 dictReleaseIterator(di); //  Release iterators
 di = NULL; /* So that we don't release it again on error. */
 }
 //  all db  After data writing , Write a terminator
 if (rdbSaveModulesAux(rdb, REDISMODULE_AUX_AFTER_RDB) == -1) goto werr;
 /* EOF opcode */
 if (rdbSaveType(rdb,RDB_OPCODE_EOF) == -1) goto werr; //  write in rdb  End of file
 /* CRC64 checksum. It will be zero if checksum computation is disabled, the
 * loading code skips the check in this case. */
 cksum = rdb->cksum;// CRC64 checksum
 memrev64ifbe(&cksum);
 if (rioWrite(rdb,&cksum,8) == 0) goto werr;
 return C_OK;
// rdb An error occurred during file generation  , Then close out
werr:
 if (error) *error = errno;
 if (di) dictReleaseIterator(di);
 return C_ERR;
}

7、 ... and 、RDB  File Protocol

The following figure for  rdb  File structure chart ,rdb  Document to “REDIS” + “RDB Version number ”  As the starting mark of the file ,

Next, start recording redis Own attribute information , edition 、 Operating system bits 、 Starting time 、 Memory usage size, etc , It also includes rdb Files are the basic information needed to access the main database after recovering from the database , Every attribute key value pair will pass OPCODE To identify the field properties of the next content , If an extension module is used , Records are also similar to attribute information , however OPCODE Values are not the same .

When all the basic information is completed , To traverse the redis All of them db, One for each iteration db, Will first record  select  Corresponding OPCODE value  FE, Next 1 Bytes represent the database number ,1 Bytes of OPCODE, The value is FB, Means to record the current whole db The total number of key value pairs and the number of keys set to expire ;

Next, record these two values in sequence

【 Next, the height of the first byte 2 Bit means that a few bytes are needed to record the length , Then you can get the total number of key value pairs , The total number of expired key values is also saved in this way 】

Next, record   Expiration time 、 type 、 key 、 value , When recording, these contents will still be preceded by  OPCODE  Value and length , all db After the data in is written , Write end identifier FF, At last, write 8 A byte check code , Whole rdb File complete ;

stay rdb In file , Record len This length , It will pass the height of the first byte 2 In order to judge the length, how many bytes need to be used to save the length , When the length is less than 64 when , high 2 Position as 00, low 6 Bits represent the actual length , high 2 Position as 01 Time table next 14 Bit is length ...  Different height 2 The length of bit parsing is different

rdb  File parsing example ：

Compare with the top rdb Let's analyze the structure diagram of dump.rdb  file , We are redis Three of them db A value is written respectively in ; For convenience, the following analyses are counted from 1 Start ;

The first line corresponds to rdb Of documents ” magic number “, namely “REDIS0009”, no need rdb Version number in version “0009” It's going to change

00000000 52 45 44 49 53 30 30 30 39 |REDIS0009 

Then there is the operation code  fa, It means that the next step is redis Property key value pairs , Some attributes are optional , Therefore, specific conditions are required to write ：

The format is ：<opcode len key len value >

00000000 fa 09 72 65 64 69 73 | .redis|
00000010 2d 76 65 72 06 35 2e 30 2e 31 34 fa 0a 72 65 64 |-ver.5.0.14..red|
00000020 69 73 2d 62 69 74 73 c0 40 fa 05 63 74 69 6d 65 |[email protected]|
00000030 c2 de 67 5f 62 fa 08 75 73 65 64 2d 6d 65 6d c2 |..g_b..used-mem.|
00000040 40 15 0f 00 fa 0c 61 6f 66 2d 70 72 65 61 6d 62 |@.....aof-preamb|
00000050 6c 65 c0 00 |le

After the attribute value is written , Start cycle writing db Relevant information and key value pairs are written in :

<opcode dbnum opcod keys_num opcode len key len value...>;00000050  No 5、6 Two bytes  fe 00,00000060  No 5、 The first 6 Bytes fe 01 ,00000070  No 7、 The first 8 Bytes fe 02  in  fe  yes db Of opcode code ,0、1、2  Each represents db The serial number of , The operation behavior is select db;00000050  No 7、8、9 Three bytes  fb 01 00,fb  Is the total number of key value pairs opcode code ,01  Represents the present db There is only one key value pair ,00  It means there is 0 Expired key value pairs , The first 10 Bytes  00  Represents the next key value pair value The type of , The first  11  Bytes  05  Represents the key The length of , That is, the next five bytes  68 65 6c 6c 6f  Namely key The content of  “hello”, It's done  key  After the parsing of is  【00000060】 value Byte length of  03, The next three bytes  61 61 69  Namely key  Corresponding value  value  “aai”, Parse down in turn to get   Key value pair  &quot;hello atome&quot;、&quot;hello ginee&quot;

00000050 fe 00 fb 01 00 00 05 68 65 6c 6c 6f | .......hello|
00000060 03 61 61 69 fe 01 fb 01 00 00 05 68 65 6c 6c 6f |.aai.......hello|
00000070 05 61 74 6f 6d 65 fe 02 fb 01 00 00 05 68 65 6c |.atome.......hel|
00000080 6c 6f 05 67 69 6e 65 65 |lo.ginee

The last encounter of the file  ff  It represents the end of the file , Last  8  Bytes are the file content check code

00000080 ff 67 09 f2 9d eb ea ec | .g......|
00000090 bc |.|

8、 ... and 、RDB  Possible faults

• fork Process right redis It is blocked , So it's possible that rdb From time to tome “ Carton ” The phenomenon

• rdb If redis Its key value pair changes too fast , May lead to rdb During the process, the system memory increases abruptly, accompanied by the sudden increase of page loss interruption of the operating system

• Single machine multi instance deployment redis  when ,rdb  The process may cause disk  IO  Overload , And it's on aof In case of redis Slow response

Nine 、 Conclusion

RDB  yes  redis  One of the guarantees of data security , In case of failure, you can pass rdb The file quickly recovers a copy of data , however  RDB  The timeliness of the data in the file is not as good as AOF;rdb The generation process of is mainly encapsulated in  rio  in , Generally, the whole generation RDB The process of has no impact on the main process .

About lingchuang group （Advance Intelligence Group）

Lingchuang group was founded in  2016  year , Committed to localized application through scientific and technological innovation , Transform and reshape the financial and retail industries , Create a service for consumers with diversified business layout 、 The ecosystem of enterprises and merchants . The group consists of two parts: enterprise business and consumer business , Enterprise business includes  ADVANCE.AI  and  Ginee, They are banks 、 Finance 、 Financial technology 、 Retail and e-commerce industry customers provide services based on  AI  Digital authentication technology 、 Risk management products and omni channel e-commerce service solutions ; Consumer business  Atome Financial  Including Asia's leading pay after pay platform  Atome  And digital financial services .

2021  year  9  month , Lingchuang group announced the completion of super  4  Billion dollars  D  Round of funding , After the completion of financing, the valuation of lingchuang group has exceeded  20  Billion dollars , Become one of the largest independent technology start-ups in Singapore .

Looking back  BREAK AWAY

Spring data JPA  Practice and principle analysis

How to solve the problem of... In the scenario of massive data update  Mysql  The deadlock problem

Enterprise class  APIs  Safety practice guide  （ It is suggested that junior and intermediate engineers collect ）

Cypress UI  Automated testing framework

serverless Make our operation and maintenance easier