GTIDs replace the file-offset pairs previously required to determine points for starting, stopping, or resuming the flow of data between source and replica. When GTIDs are in use, all the information that the replica needs for synchronizing with the source is obtained directly from the replication data stream.
      To start a replica using GTID-based replication, you do not
      include MASTER_LOG_FILE or
      MASTER_LOG_POS options in the
      CHANGE MASTER TO statement used to
      direct the replica to replicate from a given source. These options
      specify the name of the log file and the starting position within
      the file, but with GTIDs the replica does not need this nonlocal
      data. Instead, you need to enable the
      MASTER_AUTO_POSITION option. For full
      instructions to configure and start sources and replicas using
      GTID-based replication, see
      Section 2.3.4, “Setting Up Replication Using GTIDs”.
    
      The MASTER_AUTO_POSITION option is disabled by
      default. If multi-source replication is enabled on the replica,
      you need to set this option for each applicable replication
      channel. Disabling the MASTER_AUTO_POSITION
      option again causes the replica to revert to position-based
      replication.
    
      When a replica has GTIDs enabled
      (GTID_MODE=ON,
      ON_PERMISSIVE, or
      OFF_PERMISSIVE ) and the
      MASTER_AUTO_POSITION option enabled,
      auto-positioning is activated for connection to the source. The
      source must have GTID_MODE=ON set
      in order for the connection to succeed. In the initial handshake,
      the replica sends a GTID set containing the transactions that it
      has already received, committed, or both. This GTID set is equal
      to the union of the set of GTIDs in the
      gtid_executed system variable
      (@@GLOBAL.gtid_executed), and the set of GTIDs
      recorded in the Performance Schema
      replication_connection_status table
      as received transactions (the result of the statement
      SELECT RECEIVED_TRANSACTION_SET FROM
      PERFORMANCE_SCHEMA.replication_connection_status).
    
      The source responds by sending all transactions recorded in its
      binary log whose GTID is not included in the GTID set sent by the
      replica. To do this, the source first identifies the appropriate
      binary log file to begin working with, by checking the
      Previous_gtids_log_event in the header of each
      of its binary log files, starting with the most recent. When the
      source finds the first Previous_gtids_log_event
      which contains no transactions that the replica is missing, it
      begins with that binary log file. This method is efficient and
      only takes a significant amount of time if the replica is behind
      the source by a large number of binary log files. The source then
      reads the transactions in that binary log file and subsequent
      files up to the current one, sending the transactions with GTIDs
      that the replica is missing, and skipping the transactions that
      were in the GTID set sent by the replica. The elapsed time until
      the replica receives the first missing transaction depends on its
      offset in the binary log file. This exchange ensures that the
      source only sends the transactions with a GTID that the replica
      has not already received or committed. If the replica receives
      transactions from more than one source, as in the case of a
      diamond topology, the auto-skip function ensures that the
      transactions are not applied twice.
    
      If any of the transactions that should be sent by the source have
      been purged from the source's binary log, or added to the set of
      GTIDs in the gtid_purged system
      variable by another method, the source sends the error
      ER_MASTER_HAS_PURGED_REQUIRED_GTIDS
      to the replica, and replication does not start. The GTIDs of the
      missing purged transactions are identified and listed in the
      source's error log in the warning message
      ER_FOUND_MISSING_GTIDS. The
      replica cannot recover automatically from this error because parts
      of the transaction history that are needed to catch up with the
      source have been purged. Attempting to reconnect without the
      MASTER_AUTO_POSITION option enabled only
      results in the loss of the purged transactions on the replica. The
      correct approach to recover from this situation is for the replica
      to replicate the missing transactions listed in the
      ER_FOUND_MISSING_GTIDS message
      from another source, or for the replica to be replaced by a new
      replica created from a more recent backup. Consider revising the
      binary log expiration period on the source to ensure that the
      situation does not occur again.
    
      If during the exchange of transactions it is found that the
      replica has received or committed transactions with the source's
      UUID in the GTID, but the source itself does not have a record of
      them, the source sends the error
      ER_SLAVE_HAS_MORE_GTIDS_THAN_MASTER
      to the replica and replication does not start. This situation can
      occur if a source that does not have
      sync_binlog=1 set experiences a
      power failure or operating system crash, and loses committed
      transactions that have not yet been synchronized to the binary log
      file, but have been received by the replica. The source and
      replica can diverge if any clients commit transactions on the
      source after it is restarted, which can lead to the situation
      where the source and replica are using the same GTID for different
      transactions. The correct approach to recover from this situation
      is to check manually whether the source and replica have diverged.
      If the same GTID is now in use for different transactions, you
      either need to perform manual conflict resolution for individual
      transactions as required, or remove either the source or the
      replica from the replication topology. If the issue is only
      missing transactions on the source, you can make the source into a
      replica instead, allow it to catch up with the other servers in
      the replication topology, and then make it a source again if
      needed.