MySQL : Détail sur l’utilisation de la mémoire vive par MySQL
L’utilisation maximum de la mémoire vive par MySQL se calcule de la maniere suivante d’apres mysqltuner.pl :
key_buffer_size + max_tmp_table_size + ( read_buffer_size + read_rnd_buffer_size + sort_buffer_size + thread_stack + join_buffer_size ) * max_connections
max_tmp_table_size : si tmp_table_size > max_heap_table_size -> max_heap_table_size sinon tmp_table_size
Varnish : Configurer Varnish pour Drupal
Dans cet article, uniquement les spécificité de configuration pour Drupal seront indiqué
Dans la vcl_recv, on nettoie les cookies si vous ne l’avez pas déjà fait :
set req.http.Cookie = regsuball(req.http.Cookie, "(^|;\s*)(__[a-z]+|has_js)=[^;]*", "");
set req.http.Cookie = regsub(req.http.Cookie, "^;\s*", "");
if (req.http.Cookie ~ "^\s*$") {
unset req.http.Cookie;
}
On spécifie ce qu’il faut cacher, ou pas :
if (req.url ~ "^/sites/") {
unset req.http.Cookie;
}
if (req.url ~ "^/misc/") {
unset req.http.Cookie;
}
if (req.url ~ "^/modules/.*\.(js|css)\?") {
unset req.http.Cookie;
}
if (req.url ~ "cron.php") {
return (pass);
}
MySQL : Import/Export MySQL “rapide”
export.sh
Les données sont exporté avec mysqldump et le paramètre -T
- -T : Creates tab separated textfile for each table to given path. (creates .sql and .txt files). NOTE: This only works if mysqldump is run on the same machine as the mysqld daemon.
Ce script doit donc etre executé directement sur le serveur MySQL
#!/usr/bin/env bash
DST='/var/backup/mysql/dump'
for bdd in `mysql --skip-column-names -B -e "show databases;" | egrep -v "^information_schema$|^mysql$"`; do
echo -ne $bdd
mysql --skip-column-names -B -e "SHOW CREATE DATABASE $bdd;" | cut -d" " -f2- > $DST/create-$bdd.sql
for table in `mysql --skip-column-names -B $bdd -e "show tables;"`; do
mkdir $DST/$bdd 2>/dev/null 1>&2
chown mysql:mysql $DST/$bdd
echo -ne "."
mysqldump -T $DST/$bdd/ $bdd $table
done
echo -ne "\r\n"
done
import.sh
#!/usr/bin/env bash
SRC='/var/backup/mysql'
for bdd in `ls -1 $SRC`; do
echo -ne $bdd
for table in `ls -1 $SRC/$bdd | awk -F. '{print $1}' | sort | uniq`; do
mysql $bdd -e " SET foreign_key_checks = 0;
SOURCE $SRC/$bdd/$table.sql;
LOAD DATA INFILE '$SRC/$bdd/$table.txt'
INTO TABLE $table;
SET foreign_key_checks = 1;"
echo -ne "."
done
echo -ne "\r\n"
done
Nginx : Configuration Nginx pour WordPress
Cette configuration ne prend pas en compte l’utilisation du plugin w3 total cache
server {
listen 127.0.0.1:80 default;
server_name _;
location / {
root /var/www;
index index.php index.html index.htm;
if (!-e $request_filename) {
rewrite ^(.+)$ /index.php?q=$1 last;
}
location = /favicon.ico {
log_not_found off;
access_log off;
}
location = /robots.txt {
allow all;
log_not_found off;
access_log off;
}
location ~ /\. {
deny all;
access_log off;
log_not_found off;
}
gzip on;
gzip_types text/css application/x-javascript text/x-component text/richtext image/svg+xml text/plain text/xsd text/xsl text/xml image/x-icon;
location ~ \.(html|htm|rtf|rtx|svg|svgz|txt|xsd|xsl|xml)$ {
try_files $uri $uri/ $uri.html /index.php?$args;
}
location ~ \.php$ {
fastcgi_pass php;
fastcgi_index index.php;
include fastcgi_params;
fastcgi_ignore_client_abort off;
}
}
}
Si vous avez le fichier fastcgi_params de base, voici celui que j’utilise :
fastcgi_param CONTENT_LENGTH $content_length; fastcgi_param CONTENT_TYPE $content_type; fastcgi_param DOCUMENT_ROOT $document_root; fastcgi_param DOCUMENT_URI $document_uri; fastcgi_param GATEWAY_INTERFACE CGI/1.1; fastcgi_param QUERY_STRING $query_string; fastcgi_param REDIRECT_STATUS 200; fastcgi_param REMOTE_ADDR $remote_addr; fastcgi_param REMOTE_PORT $remote_port; fastcgi_param REQUEST_METHOD $request_method; fastcgi_param REQUEST_URI $request_uri; fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name; fastcgi_param SCRIPT_NAME $fastcgi_script_name; fastcgi_param SERVER_ADDR $server_addr; fastcgi_param SERVER_NAME $server_name; fastcgi_param SERVER_PORT $server_port; fastcgi_param SERVER_PROTOCOL $server_protocol; fastcgi_param SERVER_SOFTWARE nginx; fastcgi_intercept_errors on;
Varnish : Configuration de Varnish
Mise en place du dépôt Varnish et installation
Pour cela, il faut :
- Installer la clef PGP du dépôt Varnish
- Ajouter le dépôt Varnish
- Installer Varnish
curl http://repo.varnish-cache.org/debian/GPG-key.txt | apt-key add - echo "deb http://repo.varnish-cache.org/debian/ $(lsb_release -s -c) varnish-3.0" >> /etc/apt/sources.list.d/varnish.list apt-get update apt-get install varnish
Activation de varnish et configuration du port 80 a la place du port 6081
sed -i "#START#s#no#yes#" /etc/default/varnish- sed -i "s#-a :6081#-a :80#" /etc/default/varnish sed -i "s#/etc/varnish/default.vcl#/etc/varnish/production.vcl#" /etc/default/varnish
Le fichier de configuration
backend default {
.host = "127.0.0.1";
.port = "8080";
}
Appelé au début d’une requête, après que la requête complète est été reçue et analysée.
Son but est de décider si il faut exécuter la requête, comment le faire, et,
le cas échéant, quel backend utiliser.
vcl_recv
La routine vcl_recv peut se terminer avec le retour return() sur l’un des mots-clés suivants:
- code d’erreur [raison]
- Retourner le code d’erreur spécifié sur le client et d’abandonner la demande.
- pass : Switch en mode pass, passe à l’vcl_pass.
- pipe : Switch en mode pipe, passe à l’vcl_pipe.
- lookup : Recherchez l’objet demandé dans le cache.
Cela passera par la VCL vcl_hit ou vcl_miss, suivant si l’objet est dans le cache ou non.
sub vcl_recv {
if (req.http.x-forwarded-for) {
set req.http.X-Forwarded-For =
req.http.X-Forwarded-For ", " client.ip;
} else {
set req.http.X-Forwarded-For = client.ip;
}
if (req.request != "GET" &&
req.request != "HEAD" &&
req.request != "PUT" &&
req.request != "POST" &&
req.request != "TRACE" &&
req.request != "OPTIONS" &&
req.request != "DELETE") {
/* Non-RFC2616 or CONNECT which is weird. */
return (pipe);
}
if (req.request != "GET" && req.request != "HEAD") {
/* We only deal with GET and HEAD by default */
return (pass);
}
if (req.http.Authorization || req.http.Cookie) {
/* Not cacheable by default */
return (pass);
}
return (lookup);
}
vcl_pipe
La VCL pipe transfère la demande au backend ainsi que les données sans les changer.
Aucune modification ne sera faite par varnish
La routine vcl_pipe peut se terminer avec le retour return() sur l’un des mots-clés suivants:
- error code [raison] : Retourne l’erreur au client et abandonne la requête
- pipe : Procède au mode pipe
[/sourcecode]sub vcl_pipe {
return (pipe);
}
[/sourcecode]
vcl_pass
La VCL pass transmet la demande au backend et la réponse du backend est transmise au client sans être mise en cache.
Cela se passe lors de la même connexion
La VCL pass se termine par :
- pass : Procède au mode pass.
- error code [raison] : Retourne l’erreur au client et abandonne la requête
- restart : Redémarrez la transaction. Augmente le compteur redémarre.
Si le nombre de redémarrages est plus élevé que max_restarts varnish émet une erreur guru meditation
sub vcl_pass {
return (pass);
}
vcl_hash
La VCL hash permet d’ajouter des données a la table de hachage
sub vcl_hash {
set req.hash += req.url;
if (req.http.host) {
set req.hash += req.http.host;
} else {
set req.hash += server.ip;
}
return (hash);
}
vcl_hit
La VCL hit est utilisé lors de l’accès a une donnée présente dans le cache
Cette VCL se termine par :
- deliver : Délivre l’objet caché au client cela passera par la VCL délivre
- error code [raison] : Retourne l’erreur au client et abandonne la requête
- pass : Transmet le traitement a la VCL pass
- restart : Redémarrez la transaction. Augmente le compteur redémarre.
Si le nombre de redémarrages est plus élevé que max_restarts varnish émet une erreur guru meditation
sub vcl_hit {
if (!obj.cacheable) {
return (pass);
}
return (deliver);
}
vcl_miss
La VCL miss est utilisé lorsqu’un objet est absent du cache et décide si il faut ou non si il faut transmettre la demande au backend
Cette VCL se termine par :
- pass : transmet la demande a la VCL pass
- fetch : Transmet la requête au backend et transmet la demande a la VCL ketch
- error code [raison] : Retourne l’erreur au client et abandonne la requête
- restart : Redémarrez la transaction. Augmente le compteur redémarre.
Si le nombre de redémarrages est plus élevé que max_restarts varnish émet une erreur guru meditation
sub vcl_miss {
return (fetch);
}
vcl_fetch
La VCL fetch est appelé après qu’un document soit reçu avec succès d’un backend
Cette VCL se termine par :
- deliver : Met l’objet en cache et le délivre au client, la VCL deliver sera appelé.
- hit_for_pass : Utilisé dans la VCL ketch, cela va créé un objet hit_for_pass
A noter que le TTL pour l’objet hit_for_pass sera configurer avec la valeur présente dans beresp.ttl.
Le contrôle sera délégué au vcl_deliver pour la requête en cours, mais sera transmis directement au vcl_pass basés sur l’objet hit_for_pass pour toutes les sous-requêtes suivantes: - error code [raison] : Retourne l’erreur au client et abandonne la requête
- restart : Redémarrez la transaction. Augmente le compteur redémarre.
Si le nombre de redémarrages est plus élevé que max_restarts varnish émet une erreur guru meditation
sub vcl_fetch {
if (!beresp.cacheable) {
return (pass);
}
if (beresp.http.Set-Cookie) {
return (pass);
}
return (deliver);
}
vcl_deliver
La VCL deliver est utilisé avant qu’un objet caché soit délivré au client
Cette VCL se termine par :
- deliver : Délivre l’objet au client.
- error code [raison] : Retourne l’erreur au client et abandonne la requête
- restart : Redémarrez la transaction. Augmente le compteur redémarre.
Si le nombre de redémarrages est plus élevé que max_restarts varnish émet une erreur guru meditation
sub vcl_deliver {
return (deliver);
}
vcl_error
La VCL error est appelé lors d’une erreur, que ce soit du a une erreur varnish ou lié au backend.
La routine vcl_error peut se terminer par un des retour suivant :
- deliver : Livrer l’objet d’erreur au client.
- restart : Redémarrez la transaction. Augmente le compteur redémarre.
Si le nombre de redémarrages est plus élevé que max_restarts varnish émet une erreur guru meditation.
sub vcl_error {
set obj.http.Content-Type = "text/html; charset=utf-8";
synthetic {"
<!--?xml version="1.0" encoding="utf-8"?-->
"} obj.status " " obj.response {"</pre>
<h1>Error "} obj.status " " obj.response {"</h1>
<pre>"} obj.response {"</pre>
<h3>Guru Meditation:</h3>
<pre>XID: "} req.xid {"</pre>
<hr />
<pre>Varnish cache server
"};
return (deliver);
}
MySQL : Convertir toutes les tables MyISAM en InnoDB
Pour toutes les tables de toutes les bases
“Version” séquentiel
la convertion de la table suivante sera faite que si la precedente est fini (ingnorer les erreurs pour les tables deja en InnoDB
)
#!/usr/bin/env bash for db in `mysql --batch --skip-column-names -e "show databases;" | egrep -v "mysql|information_schema|performance_schema|lost"`; do echo "# "$db for table in `echo "show tables" | mysql --batch --skip-column-names $db`; do echo "-- "$table mysql $db -e "ALTER TABLE $table ENGINE = InnoDB;" done done
“Version” Bourine
#!/usr/bin/env bash for db in `mysql --batch --skip-column-names -e "show databases;" | egrep -v "mysql|information_schema|performance_schema|lost"`; do echo "# "$db for table in `echo "show tables" | mysql --batch --skip-column-names $db`; do echo "-- "$table mysql $db -e "ALTER TABLE $table ENGINE = InnoDB;" & done done
Pour toutes les tables d’une base
Vous pouvez le faire de manière soft (Table par table)
#!/usr/bin/env bash DATABASENAME="votrebdd" for i in `echo "show tables" | mysql --batch --skip-column-names $DATABASENAME`; do mysql $DATABASENAME -e "ALTER TABLE `$i` ENGINE = InnoDB;" done
Ou en version “Multithread” (Bourine)
#!/usr/bin/env bash DATABASENAME="votrebdd" for i in `echo "show tables" | mysql --batch --skip-column-names $DATABASENAME`; do mysql $DATABASENAME -e "ALTER TABLE `$i` ENGINE = InnoDB;" & done
MySQL : Extraire les requêtes SQL depuis un binlog au format RAW
Le format des log binaires RAW a un gros inconviant, lorsque vous voulez rejouer des requetes a partir des log binaires, l’extraction de celle ci est plus complexe.
#!/bin/sh
LIST=$(ls -1 /var/log/mysql/mysql-bin.* | grep -v index | awk -F "." '{print $2}')
DIRDST="/mnt/pad/"
DIRSRC="/var/log/mysql"
DATABASE="votrebdd"
echo -n > $DIRDST"/"result.txt
for i in $LIST; do
echo -ne $i
mysqlbinlog --database=$DATABASE --base64-output=DECODE-ROWS --verbose --start-datetime="2012-01-06 00:00:00" --stop-datetime="2012-01-06 13:00:00" $DIRSRC"/mysql-bin."$i | grep "^###">> $DIRDST"/"result.txt
echo -ne "\tdone\r\n"
done
Supprimez ou modifiez les parametres suivant en fonction de vos besoin :
- –start-datetime : Date de debut d’extraction
- –stop-datetime : Apres cette date, les logs ne seront plus extrait
Le résultat est presque injectable directement dans MySQL, il nécessite encore quelque traitement
PostgreSQL : Procéder a une mise a jour de PostgreSQL
Préparation
Vérifier l’encodage des bases :
srv-src:~$ su - postgres
postgres@srv-src:~$ psql -l
Liste des bases de données
Nom | Propriétaire | Encodage
-----------+--------------+----------
bdd1 | user1 | UTF8
{...}
(9 lignes)
Migration
- Dumper l’intégralité des données :
pg_dumpall > outputfile
- Initialiser le nouvel emplacement en UTF8:
/usr/local/pgsql/bin/initdb --locale=UTF8 -D /usr/local/pgsql/data
Le dossier doit être comme cela :
drwx------ 5 postgres postgres 4096 4 nov. 15:25 base drwx------ 2 postgres postgres 4096 4 nov. 15:25 global drwx------ 2 postgres postgres 4096 4 nov. 15:25 pg_clog -rw------- 1 postgres postgres 3652 4 nov. 15:25 pg_hba.conf -rw------- 1 postgres postgres 1631 4 nov. 15:25 pg_ident.conf drwx------ 4 postgres postgres 4096 4 nov. 15:25 pg_multixact drwx------ 2 postgres postgres 4096 4 nov. 15:25 pg_stat_tmp drwx------ 2 postgres postgres 4096 4 nov. 15:25 pg_subtrans drwx------ 2 postgres postgres 4096 4 nov. 15:25 pg_tblspc drwx------ 2 postgres postgres 4096 4 nov. 15:25 pg_twophase -rw------- 1 postgres postgres 4 4 nov. 15:25 PG_VERSION drwx------ 3 postgres postgres 4096 4 nov. 15:25 pg_xlog -rw------- 1 postgres postgres 16903 4 nov. 15:25 postgresql.conf lrwxrwxrwx 1 root root 36 4 nov. 15:28 server.crt -> /etc/ssl/certs/ssl-cert-snakeoil.pem lrwxrwxrwx 1 root root 38 4 nov. 15:29 server.key -> /etc/ssl/private/ssl-cert-snakeoil.key
- Importer les données :
/usr/local/pgsql/bin/psql -d postgres -f outputfile
Nginx : Configurer php dans un alias
Dans le cas ou vous devez faire un alias, pour que l’exécution de php fonctionne, vous devez modifié le documentroot au niveau des paramètres fastcgi
Exemple :
root /var/www/somesite;
location /pma/ {
alias /usr/share/phpmyadmin/;
}
location ~ ^/pma/(.+\.php)$ {
alias /usr/share/phpmyadmin/$1;
include fastcgi_params;
fastcgi_pass php;
fastcgi_param DOCUMENT_ROOT /usr/share/phpmyadmin;
}
Add One