Todos os dados são InnoDB

Isto é o que lhe dará um instantâneo exato do momento dos dados:

mysqldump -uuser -ppass --single-transaction --routines --triggers --all-databases > backup_db.sql

--single-transactionproduz um ponto de verificação que permite que o dump capture todos os dados anteriores ao ponto de verificação enquanto recebe as alterações de entrada. Essas alterações recebidas não se tornam parte do dump. Isso garante o mesmo point-in-time para todas as tabelas.

--routinesdespeja todos os procedimentos armazenados e funções armazenadas

--triggersdespeja todos os gatilhos para cada tabela que os possui

Todos os dados são MyISAM ou Mix de InnoDB/MyISAM

Você terá que impor um bloqueio de leitura global, executar o mysqldump e liberar o bloqueio global

mysql -uuser -ppass -Ae"FLUSH TABLES WITH READ LOCK; SELECT SLEEP(86400)" &
sleep 5
mysql -uuser -ppass -ANe"SHOW PROCESSLIST" | grep "SELECT SLEEP(86400)" > /tmp/proclist.txt
SLEEP_ID=`cat /tmp/proclist.txt | awk '{print $1}'`
echo "KILL ${SLEEP_ID};" > /tmp/kill_sleep.sql
mysqldump -uuser -ppass --single-transaction --routines --triggers --all-databases > backup_db.sql
mysql -uuser -ppass -A < /tmp/kill_sleep.sql

De uma chance !!!

ATUALIZAÇÃO 2012-06-22 08:12 EDT

Como você tem menos de 50 MB de dados totais, tenho outra opção. Em vez de lançar um comando SLEEP em segundo plano para manter o bloqueio de leitura global por 86400 segundos (essas 24 horas) apenas para obter o ID do processo e matar fora, vamos tentar definir um tempo limite de 5 segundos no mysql em vez do sistema operacional:

SLEEP_TIMEOUT=5
SQLSTMT="FLUSH TABLES WITH READ LOCK; SELECT SLEEP(${SLEEP_TIMEOUT})"
mysql -uuser -ppass -Ae"${SQLSTMT}" &
mysqldump -uuser -ppass --single-transaction --routines --triggers --all-databases > backup_db.sql

Essa é uma abordagem mais limpa e simples para bancos de dados muito pequenos.

• Para tabelas InnoDB, você deve usar a --single-transactionopção, conforme mencionado em outra resposta.
• Para MyISAM existe --lock-tables.

Veja a documentação oficial aqui

Aqui está como eu fiz isso. Deve funcionar em todos os casos, uma vez que usa FLUSH TABLES WITH READ LOCK.

#!/bin/bash

DB=example
DUMP_FILE=export.sql

# Lock the database and sleep in background task
mysql -uroot -proot $DB -e "FLUSH TABLES WITH READ LOCK; DO SLEEP(3600);" &
sleep 3

# Export the database while it is locked
mysqldump -uroot -proot --opt $DB > $DUMP_FILE

# When finished, kill the previous background task to unlock
kill $! 2>/dev/null
wait $! 2>/dev/null

echo "Finished export, and unlocked !"

O comando shell sleepé apenas para garantir que a tarefa em segundo plano executando o comando de bloqueio mysql seja executada antes do início do mysqldump. Você pode reduzi-lo para 1 segundo e ainda deve estar bem. Aumente para 30 segundos e tente inserir um valor em qualquer tabela de outro cliente durante esses 30 segundos você verá que está bloqueado.

Existem 2 vantagens em usar este bloqueio manual em segundo plano, em vez de usar as mysqldumpopções --single-transactione --lock-tables:

1. Isso bloqueia tudo, se você misturou tabelas MyISAM/InnoDB.
2. Você pode executar outros comandos além do mysqldumpdurante o mesmo período de bloqueio. É útil, por exemplo, ao configurar a replicação em um nó mestre, porque você precisa obter a posição do log binário SHOW MASTER STATUS;no estado exato do dump que você criou (antes de desbloquear o banco de dados), para poder criar um escravo de replicação.

Se você quiser fazer isso para MyISAM ou tabelas mistas sem nenhum tempo de inatividade devido ao bloqueio das tabelas, você pode configurar um banco de dados escravo e tirar seus instantâneos de lá. A configuração do banco de dados escravo, infelizmente, causa algum tempo de inatividade para exportar o banco de dados ativo, mas uma vez que esteja em execução, você poderá bloquear suas tabelas e exportar usando os métodos descritos por outros. Quando isso estiver acontecendo, ele ficará para trás do mestre, mas não impedirá o mestre de atualizar suas tabelas e o recuperará assim que o backup for concluído.

A sugestão da documentação oficial do mysql é que você deve ter um banco de dados mestre "M1" e um banco de dados escravo "S1" que é descrito em "Cenário 2: Backup com um escravo somente leitura" Fazendo backup de um mestre ou escravo fazendo-o Somente leitura

Você deve definir o banco de dados escravo somente leitura e executar

se você tiver uma tabela MYISAM muito grande e precisar despejar a tabela sem bloqueio e evitar alta carga do servidor, poderá usar o script a seguir.

#!/bin/sh

my_user="user"
my_password="password"
my_db="vpn"
my_table="traffic"
my_step=100000

read -p "Dumping table ${my_db}.${my_table} to ${my_table}.sql?" yn
case $yn in
    [Yy]* ) break;;
    * ) echo "User cancel."; exit;;
esac

my_count=$(mysql $my_db -u $my_user -p$my_password -se "SELECT count(*) FROM $my_table")
my_count=$(($my_count + 0))

if [ ! $my_count ]
then
    echo "No records found"
    exit
fi

echo "Records in table ${my_db}.${my_table}: ${my_count}"

echo "" > $my_table.sql

max_progress=60

for (( limit=0; limit<=$my_count; limit+=$my_step )); do
    progress=$((max_progress * ( limit + my_step) / my_count))

    echo -ne "Dumping ["
    for ((i=0; i<$progress; i ++)); do
        echo -ne "#"
    done
    for ((; i<$max_progress; i ++)); do
        echo -ne "."
    done

    mysqldump -u $my_user -p$my_password --complete-insert --no-create-info --opt --where="1 limit $limit , $my_step" $my_db $my_table >> $my_table.sql
    echo "" >> $my_table.sql

    echo -ne "] $((100 * ( limit + my_step ) / my_count)) %"
    echo -ne "\r"

    sleep 1

done

echo -ne "\n"