Supprimez les messages d'avertissement à l'aide de mysql depuis le terminal, mais le mot de passe est écrit dans le script bash

Lorsque j'ai essayé d'exécuter la commande suivante sur MySQL depuis Terminal:

mysql -u $user -p$password -e "statement"

L'exécution fonctionne comme prévu, mais elle émet toujours un avertissement:

Avertissement: L'utilisation d'un mot de passe sur l'interface de ligne de commande peut être non sécurisée.

Cependant, je dois effectuer la déclaration ci-dessus en utilisant une variable d'environnement ( $password) qui stocke mon mot de passe, car je veux exécuter la commande de manière itérative dans le script bash à partir de Terminal, et je n'aime vraiment pas l'idée d'attendre une invite qui s'affiche et me forçant à saisir mon mot de passe 50 ou 100 fois dans un seul script. Voici donc ma question:

• Est-il possible de supprimer l'avertissement? La commande fonctionne correctement comme je l'ai dit, mais la fenêtre devient assez désordonnée lorsque je boucle et exécute la commande 50 ou 100 fois.

• Dois-je obéir au message d'avertissement et NE PAS écrire mon mot de passe dans mon script? Si c'est le cas, dois-je taper mon mot de passe chaque fois que l'invite me force à le faire?

Courir man mysqln'aide pas, en disant seulement

--show-warnings
Faire apparaître des avertissements après chaque instruction, le cas échéant. Cette option s'applique au mode interactif et par lots.

et ne mentionne rien sur la façon de désactiver la fonctionnalité, si je ne manque pas quelque chose.

Je suis sur OS X 10.9.1 Mavericks et utilise MySQL 5.6 de homebrew.

Si votre version client / serveur MySQL est un moyen 5.6.xa d'éviter le message AVERTISSEMENT, utilisez les outils mysql_config_editor :

mysql_config_editor set --login-path=local --host=localhost --user=username --password

Ensuite, vous pouvez utiliser dans votre script shell:

mysql --login-path=local  -e "statement"

Au lieu de:

mysql -u username -p pass -e "statement"

J'utilise quelque chose comme:

mysql --defaults-extra-file=/path/to/config.cnf

ou

mysqldump --defaults-extra-file=/path/to/config.cnf 

Où config.cnf contient:

[client]
user = whatever
password = whatever
host = whatever

Cela vous permet d'avoir plusieurs fichiers de configuration - pour différents serveurs / rôles / bases de données. L'utilisation de ~ / .my.cnf ne vous permettra d'avoir qu'un seul ensemble de configuration (bien qu'il puisse s'agir d'un ensemble utile de valeurs par défaut).

Si vous utilisez une distribution basée sur Debian et que vous exécutez en tant que root, vous pouvez ignorer ce qui précède et utiliser simplement /etc/mysql/debian.cnf pour entrer ...:

mysql --defaults-extra-file=/etc/mysql/debian.cnf

Une méthode pratique (mais tout aussi peu sûre) consiste à utiliser:

MYSQL_PWD=xxxxxxxx mysql -u root -e "statement"

Notez que les documents officiels le déconseillent.
Voir 6.1.2.1 Instructions pour l'utilisateur final pour la sécurité des mots de passe (Manuel Mysql pour la version 5.6) :

Stocker votre mot de passe dans la MYSQL_PWDvariable d'environnement

Cette méthode de spécification de votre mot de passe MySQL doit être considérée comme extrêmement précaire et ne doit pas être utilisée. Certaines versions de ps incluent une option pour afficher l'environnement des processus en cours d'exécution. Sur certains systèmes, si vous le définissez MYSQL_PWD, votre mot de passe est exposé à tout autre utilisateur qui exécute ps . Même sur les systèmes sans une telle version de ps , il est imprudent de supposer qu’il n’existe aucune autre méthode permettant aux utilisateurs d’examiner les environnements de processus.

Si vous souhaitez utiliser un mot de passe dans la ligne de commande, j'ai constaté que cela fonctionne pour filtrer le message d'erreur spécifique:

mysqlcommand 2>&1 | grep -v "Warning: Using a password"

Il s'agit essentiellement de rediriger l'erreur standard vers la sortie standard - et d'utiliser grep pour supprimer toutes les lignes qui correspondent à "Avertissement: utilisation d'un mot de passe".

De cette façon, vous pouvez voir toute autre sortie, y compris les erreurs. Je l'utilise pour divers scripts shell, etc.

Voici comment j'ai obtenu mon script bash pour que mes sauvegardes quotidiennes de bases de données mysqldump fonctionnent de manière plus sécurisée. Il s'agit d'une extension de la grande réponse de Cristian Porta.

1. Utilisez d'abord mysql_config_editor (fourni avec mysql 5.6+) pour configurer le fichier de mot de passe crypté. Supposons que votre nom d'utilisateur soit "db_user". Exécution à partir de l'invite du shell:

   mysql_config_editor set --login-path=local --host=localhost --user=db_user --password

   Il vous demande le mot de passe. Une fois que vous l'avez entré, l'utilisateur / pass est enregistré crypté dans votrehome/system_username/.mylogin.cnf

   Bien sûr, changez "system_username" en votre nom d'utilisateur sur le serveur.

2. Modifiez votre script bash à partir de ceci:

   mysqldump -u db_user -pInsecurePassword my_database | gzip > db_backup.tar.gz

   pour ça:

   mysqldump --login-path=local my_database | gzip > db_backup.tar.gz

Plus de mots de passe exposés.

Le moyen le plus simple est

mysql -u root -pMYPASSWORD -e "show databases" 2>/dev/null

Vous pouvez également exécuter mysql_config_editor dans votre script pour transmettre le mot de passe lors de la spécification du chemin de connexion

expect -c "
spawn mysql_config_editor set --login-path=$mySqlUser --host=localhost --user=$mySqlUser --password
expect -nocase \"Enter password:\" {send \"$mySqlPassword\r\"; interact}
"

Cela démarre une session attendue qui peut être utilisée dans les scripts pour interagir avec les invites

Voir cet article

ok, solution sans fichiers temporaires ou quoi que ce soit:

mysql --defaults-extra-file=<(echo $'[client]\npassword='"$password") -u $user -e "statement"

c'est similaire à ce que d'autres ont mentionné, mais ici vous n'avez pas besoin d'un fichier réel, cette partie de la commande simule le fichier: <(echo ...) (remarquez qu'il n'y a pas d'espace au milieu de<(

shell> mysql_config_editor set --login-path=local
     --host=localhost --user=localuser --password
Enter password: enter password "localpass" here
shell> mysql_config_editor set --login-path=remote
     --host=remote.example.com --user=remoteuser --password
Enter password: enter password "remotepass" here

Pour voir ce que mysql_config_editor a écrit dans le fichier .mylogin.cnf, utilisez la commande print:

shell> mysql_config_editor print --all
[local]
user = localuser
password = *****
host = localhost
[remote]
user = remoteuser
password = *****
host = remote.example.com

La commande d'impression affiche chaque chemin de connexion sous la forme d'un ensemble de lignes commençant par un en-tête de groupe indiquant le nom du chemin de connexion entre crochets, suivi des valeurs d'option pour le chemin de connexion. Les valeurs de mot de passe sont masquées et n'apparaissent pas en texte clair.

Comme le montrent les exemples précédents, le fichier .mylogin.cnf peut contenir plusieurs chemins de connexion. De cette façon, mysql_config_editor facilite la configuration de plusieurs «personnalités» pour la connexion à différents serveurs MySQL. Chacun de ces éléments peut être sélectionné par son nom ultérieurement à l'aide de l'option --login-path lorsque vous appelez un programme client. Par exemple, pour vous connecter au serveur local, utilisez cette commande:

shell> mysql --login-path=local

Pour vous connecter au serveur distant, utilisez cette commande:

shell> mysql --login-path=remote

Depuis https://gist.github.com/nestoru/4f684f206c399894952d

# Let us consider the following typical mysql backup script:
mysqldump --routines --no-data -h $mysqlHost -P $mysqlPort -u $mysqlUser -p$mysqlPassword $database

# It succeeds but stderr will get:
# Warning: Using a password on the command line interface can be insecure.
# You can fix this with the below hack:
credentialsFile=/mysql-credentials.cnf
echo "[client]" > $credentialsFile
echo "user=$mysqlUser" >> $credentialsFile
echo "password=$mysqlPassword" >> $credentialsFile
echo "host=$mysqlHost" >> $credentialsFile
mysqldump --defaults-extra-file=$credentialsFile --routines --no-data $database

# This should not be IMO an error. It is just a 'considered best practice'
# Read more from http://thinkinginsoftware.blogspot.com/2015/10/solution-for-mysql-warning-using.html

Une autre alternative consiste à utiliser sshpass pour appeler mysql, par exemple:

sshpass -p topsecret mysql -u root -p username -e 'statement'

Un script de workaroud simple. Nommez ce "mysql", et placez-le dans votre chemin avant "/ usr / bin". Variantes évidentes pour d'autres commandes, ou si le texte d'avertissement est différent.

#!/bin/sh

(
(
(
(
(
    /usr/bin/mysql "$@"
) 1>&9 
) 2>&1
) | fgrep -v 'mysql: [Warning] Using a password on the command line interface can be insecure.'
) 1>&2 
) 9>&1

Voici une solution pour Docker dans un script / bin / sh:

docker exec [MYSQL_CONTAINER_NAME] sh -c 'exec echo "[client]"> /root/mysql-credentials.cnf'

docker exec [MYSQL_CONTAINER_NAME] sh -c 'exec echo "user = root" >> /root/mysql-credentials.cnf'

docker exec [MYSQL_CONTAINER_NAME] sh -c 'exec echo "mot de passe = $ MYSQL_ROOT_PASSWORD" >> /root/mysql-credentials.cnf'

docker exec [MYSQL_CONTAINER_NAME] sh -c 'exec mysqldump --defaults-extra-file = / root / mysql-credentials.cnf --all-databases'

Remplacez [MYSQL_CONTAINER_NAME] et assurez-vous que la variable d'environnement MYSQL_ROOT_PASSWORD est définie dans votre conteneur.

J'espère que cela vous aidera comme cela pourrait m'aider!

Vous pouvez également simplement rediriger la sortie d'erreur standard STDERR vers / dev / null

Alors faites juste:

mysql -u $user -p$password -e "statement" 2> /dev/null

Personnellement, j'utilise un wrapper de script pour détecter cette erreur. Voici un exemple de code:

#!/bin/bash

#echo $@ | cat >> /home/mysqldump.log 2>/dev/null
ERR_FILE=/tmp/tmp_mdump.err

# Execute dumper
/usr/bin/mysqldump $@ 2>$ERR_FILE

# Determine error and remove tmp file
ERROR=`cat $ERR_FILE`
rm $ERR_FILE

# Handle an error
if [ "" != "$ERROR" ]; then

        # Error occured
        if [ "Warning: Using a password on the command line interface can be insecure." != "$ERROR" ]; then
                echo $ERROR >&2
                exit 1
        fi
fi

Pour PowerShell ( pwsh, pas bash), c'était une solution assez rube-goldberg ... Ma première tentative a été d'envelopper les appels mysqldans une try/catchfonction, mais en raison d'un comportement étrange dans la gestion des erreurs PowerShell , ce n'était pas viable.

La solution était de remplacer le $ErrorActionPreferencejuste assez longtemps pour combiner et la capture STDERRet STDOUTRequérir et analyser le mot ERRORet re-lancer au besoin. La raison pour laquelle nous n'avons pas pu intercepter et publier "^mysql.*Warning.*password"est que PowerShell gère et déclenche l'erreur comme un seul flux, vous devez donc tout capturer pour filtrer et relancer. : /

Function CallMySQL() {
    # Cache the error action preference
    $_temp = $ErrorActionPreference
    $ErrorActionPreference = "Continue"

    # Capture all output from mysql
    $output = (&mysql --user=foo --password=bar 2>&1)

    # Restore the error action preference
    $ErrorActionPreference = $_temp

    if ($output -match "ERROR") {
        throw $output
    } elseif($output) {
        "   Swallowing $output"
    } else {
        "   No output"
    }
}

Remarque: PowerShell est disponible pour Unix, cette solution est donc multi-plateforme. Il peut être adapté bashavec quelques modifications mineures de syntaxe.

Avertissement: Il existe des dizaines de cas marginaux où cela ne fonctionne pas, tels que des messages d'erreur ou des instructions non anglais qui renvoient le mot ERRORn'importe où dans la sortie, mais cela a suffi à avaler l'avertissement pour un appel de base mysqlsans bombarder le script entier. J'espère que d'autres trouveront cela utile.

Ce serait bien de mysqlsimplement ajouter une option pour supprimer cet avertissement.

S'il vous arrive d'utiliser Rundeck pour planifier vos tâches, ou toute autre plate-forme où vous demandez un mylogin.cnffichier, j'ai utilisé avec succès le code shell suivant pour fournir un nouvel emplacement pour le fichier avant de procéder aux appels SQL:

if test -f "$CUSTOM_MY_LOGINS_FILE_PATH"; then
   chmod 600 $CUSTOM_MY_LOGINS_FILE_PATH
   export MYSQL_TEST_LOGIN_FILE="$CUSTOM_MY_LOGINS_FILE_PATH"
fi

...

result=$(mysql --login-path=production -NBA -D $schema -e "$query")

Où MYSQL_TEST_LOGIN_FILEest une variable d'environnement qui peut être définie sur un chemin de fichier différent de celui par défaut.

Ceci est particulièrement utile si vous exécutez dans un processus fourchu et ne pouvez pas déplacer ou copier des fichiers dans le $HOMErépertoire.

Voir la documentation ici.

la meilleure solution est d'utiliser l'alias:

alias [yourapp]-mysql="mysql -u root -psomepassword -P3306 -h 127.0.0.1"

par exemple, mettez ceci dans votre script:

alias drupal-mysql="mysql -u root -psomepassword -P3306 -h 127.0.0.1"

puis plus tard dans votre script pour charger une base de données:

drupal-mysql database_name < database_dump.sql

pour exécuter une instruction:

drupal-mysql -e "EXEC SOMESTATEMENT;"

Définissez l'assistant:

remove-warning () {
    grep -v 'mysql: [Warning] Using a password on the command line interface can be insecure.'
}

Utilise le:

mysql -u $user -p$password -e "statement" 2>&1 | remove-warning

Tachaan! Votre code est propre et agréable à lire

(testé avec bash)

Une autre solution (à partir d'un script, par exemple):

 sed -i'' -e "s/password=.*\$/password=$pass/g" ~/.my.cnf
 mysql -h $host -u $user $db_name -e "$sql_cmd"

L' -i''option est ici pour la compatibilité avec Mac OS X. Les systèmes d'exploitation UNIX standard peuvent utiliser directement-i

Le problème que j'avais était d'utiliser la sortie dans un conditionnel dans un script bash.

Ce n'est pas élégant, mais dans un docker env, cela ne devrait vraiment pas avoir d'importance. Fondamentalement, cela ne fait qu'ignorer la sortie qui n'est pas sur la dernière ligne. Vous pouvez faire de même avec awk, et changer pour renvoyer tout sauf la première ligne, etc.

Cela ne renvoie que la dernière ligne

mysql -u db_user -pInsecurePassword my_database ... | sed -e '$!d'

Il ne supprimera pas l'erreur, mais il s'assurera que vous pouvez utiliser la sortie d'une requête dans un script bash.

La façon la plus simple:

mysql -u root -p YOUR_DATABASE

Saisissez-le et vous devrez saisir votre mot de passe.

Remarque: Oui, sans point-virgule.

Vous pouvez exécuter mySQL et supprimer les messages d'avertissement et d'erreur en utilisant / dev / null par exemple:

# if you run just a SQL-command
mysql -u ${USERNAME} -p${PASSWORD} -h ${HOST} ${DATABASE} -e "${STATEMENT}" &> /dev/null

# Or you can run SQL-script as a file
mysql -u ${USERNAME} -p${PASSWORD} -h ${HOST} ${DATABASE} < ${FILEPATH} &> /dev/null

Où:

${USERNAME} - existing mysql user

${PASSWORD} - password

${HOST}     - ip or hostname, for example 'localhost'

${DATABASE} - name of database

${STATEMENT}- SQL command

${FILEPATH} - Path to the SQL-script

prendre plaisir!

Cela a fonctionné pour moi - vient d'être ajouté 2> nullaprès le $(mysql_command), et il supprimera uniquement les messages d'erreurs et d'avertissement.