Aof related configuration (redis.conf):
appendonly yes
If AOF persistence is turned on, yes is turned on, no is not turned on

appendfilename appendonly.aof
Specify the AOF log file name, default name: appendonly.aof

appendfsync everysec
When to write data to disk, redis provides three modes:
no: Without fsync, OS determines the time granularity of data brush disk, which has high performance.
always: Do fsync every time you write, safe
everysec: At least 1s after the last fsync, compromise

no-appendfsync-on-rewrite no
When Aof log is rewritten, fsync when log is written or not. If the system encounters latency problems, it is recommended to set yes (rewrite does not force fsync)

auto-aof-rewrite-percentage 100
When the growth of Aof log exceeds the specified proportion, rewrite log file, set to 0 to indicate that Aof log is not automatically rewritten

auto-aof-rewrite-min-size 64mb
When you start rewriting Aof log, the minimum size of Aof log

Write Aof log when updating data:

Execute a client command process

/* Call() is the core of Redis execution of a command */
void call(redisClient *c) {
    long long dirty, start = ustime(), duration;

    dirty = server.dirty;
    c->cmd->proc(c);    //Command execution
    dirty = server.dirty-dirty;   //Calculate the dirty value, the update operation will change the dirty value
    duration = ustime()-start;
    slowlogPushEntryIfNeeded(c->argv,c->argc,duration);
    if (server.appendonly && dirty > 0) //AOF is started and the data is updated
        feedAppendOnlyFile(c->cmd,c->db->id,c->argv,c->argc); 
    if ((dirty > 0 || c->cmd->flags & REDIS_CMD_FORCE_REPLICATION) &&
        listLength(server.slaves))
        replicationFeedSlaves(server.slaves,c->db->id,c->argv,c->argc);
    if (listLength(server.monitors))
        replicationFeedMonitors(server.monitors,c->db->id,c->argv,c->argc);
    server.stat_numcommands++;
}

void feedAppendOnlyFile(struct redisCommand *cmd, int dictid, robj **argv, int argc) {

    if (dictid != server.appendseldb) { //If the current database is inconsistent with the previous one, write a command to change the database.
        char seldb[64];

        snprintf(seldb,sizeof(seldb),"%d",dictid);
        buf = sdscatprintf(buf,"*2\r\n$6\r\nSELECT\r\n$%lu\r\n%s\r\n",
            (unsigned long)strlen(seldb),seldb);
        server.appendseldb = dictid;
    }

     .....

    server.aofbuf = sdscatlen(server.aofbuf,buf,sdslen(buf)); //Put data in atobuf

    if (server.bgrewritechildpid != -1)  //If the child process is doing Aof log rewrite, the data is put into the buffer bgrewritebuf at the same time
        server.bgrewritebuf = sdscatlen(server.bgrewritebuf,buf,sdslen(buf));

    sdsfree(buf);
}

void flushAppendOnlyFile(int force) {
    ssize_t nwritten;
    int sync_in_progress = 0;

    if (sdslen(server.aofbuf) == 0) return;

    if (server.appendfsync == APPENDFSYNC_EVERYSEC)   //When append fsync is set to everysec, check whether there is data waiting for fsync
        sync_in_progress = bioPendingJobsOfType(REDIS_BIO_AOF_FSYNC) != 0;

    //If appendfsync is set to everysec, if the main thread waits for fsync for no more than 2 seconds during blocking, it returns (the data is cached in aofbuf)
    if (server.appendfsync == APPENDFSYNC_EVERYSEC && !force) {
        if (sync_in_progress) {
            if (server.aof_flush_postponed_start == 0) {
                server.aof_flush_postponed_start = server.unixtime;
                return;
            } else if (server.unixtime - server.aof_flush_postponed_start < 2) {
                return;
            }
            redisLog(REDIS_NOTICE,"Asynchronous AOF fsync is taking too long (disk is busy?). Writing the AOF buffer without waiting for fsync to complete, this may slow down Redis.");
        }
    }
    server.aof_flush_postponed_start = 0;
   
    //Write Aof log
    nwritten = write(server.appendfd,server.aofbuf,sdslen(server.aofbuf));
    if (nwritten != (signed)sdslen(server.aofbuf)) {
        if (nwritten == -1) {
            redisLog(REDIS_WARNING,"Exiting on error writing to the append-only file: %s",strerror(errno));
        } else {
            redisLog(REDIS_WARNING,"Exiting on short write while writing to the append-only file: %s",strerror(errno));
        }
        exit(1);
    }
    server.appendonly_current_size += nwritten; //Record log file size

    //Empty aofbuf, reuse if aofbuf is small
    if ((sdslen(server.aofbuf)+sdsavail(server.aofbuf)) < 4000) {
        sdsclear(server.aofbuf);
    } else {
        sdsfree(server.aofbuf);
        server.aofbuf = sdsempty();
    }

    //If no-appendfsync-on-rewrite is set to yes and a child process is currently rewrite, it returns directly
    if (server.no_appendfsync_on_rewrite &&
        (server.bgrewritechildpid != -1 || server.bgsavechildpid != -1))
            return;

    /* Perform the fsync if needed. */
    if (server.appendfsync == APPENDFSYNC_ALWAYS) {
        /* aof_fsync is defined as fdatasync() for Linux in order to avoid
         * flushing metadata. */
        aof_fsync(server.appendfd); /* Let's try to get this data on the disk */
        server.lastfsync = server.unixtime;
    } else if ((server.appendfsync == APPENDFSYNC_EVERYSEC &&
                server.unixtime > server.lastfsync)) {
        if (!sync_in_progress) aof_background_fsync(server.appendfd);
        server.lastfsync = server.unixtime;
    }
}

void aof_background_fsync(int fd) {
    bioCreateBackgroundJob(REDIS_BIO_AOF_FSYNC,(void*)(long)fd,NULL,NULL);
}

aboutappendfsyncSet to everysec The situation, fsync It is done by a separate threadrewrite Aof log: In two cases, redis Would be right aof log do rewrite1.  Configuration automation rewrite Threshold occurrence 2.  Client Send bgrewriteaof command

Receive bgrewriteaof Command Execution Function:

void bgrewriteaofCommand(redisClient *c) {
    if (server.bgrewritechildpid != -1) {
        addReplyError(c,"Background append only file rewriting already in progress");
    } else if (server.bgsavechildpid != -1) {
        server.aofrewrite_scheduled = 1;
        addReplyStatus(c,"Background append only file rewriting scheduled");
    } else if (rewriteAppendOnlyFileBackground() == REDIS_OK) {
        addReplyStatus(c,"Background append only file rewriting started");
    } else {
        addReply(c,shared.err);
    }
}