Serveur dédié : transférer et héberger un nouveau domaine sur votre serveur

Aujourd’hui, nous allons voir comment héberger un nouveau domaine sur le serveur, en simplifiant au maximum les procédures.

Le nom de domaine sera réservé chez OVH et le site hébergé sur notre serveur Debian. Nous allons servir le site avec NginX en HTTPS grâce à un certificat SSL fourni gratuitement par Let’s Encrypt.

Enfin, on utilisera le serveur email existant et on ajoutera la configuration OpenDKIM pour signer et authentifier tous les emails sortants du domaine.

Nom de domaine

J’achète mes noms de domaine chez OVH parce que le prix est relativement raisonnable (comparé à mon ancien registrar).

Au moment de la commande, faites pointer le nouveau domaine vers les DNS du serveur.

Si votre serveur n’est pas chez OVH, il suffit d’aller dans Domaines > Serveurs DNS et de renseigner le DNS primaire et secondaire de votre serveur.

Configuration DNS dans BIND

Une fois le domaine commandé, si vous vous rendez dans le Manager OVH, vous vous rendrez compte que le bouton DNS est en rouge : c’est normal puisqu’il nous faut paramétrer notre nouveau domaine dans BIND, notre serveur de noms.

On édite la configuration de BIND :

nano /etc/bind/named.conf.local

et on lui indique que nous créons une nouvelle zone :

zone "example.com" {
        type master;
        file "/etc/bind/example.com.hosts";
        allow-query { any; };
};Code language: JavaScript (javascript)

On crée maintenant notre fichier de zone:

nano /etc/bind/example.com.hosts

$ttl 84600
$ORIGIN example.com.

@       IN      SOA     XXXXXX.kimsufi.com. root.example.net. (
                        2018012801
                        14400
                        3600
                        604800
                        84600 )

; NAMESERVERS
 IN     NS      XXXXXX.kimsufi.com.
 IN     NS      ns.kimsufi.com.

example.com.   IN      A       XXX.XXX.XXX.XXX
example.com.   IN      AAAA    4001:41d0:1:4462::1
example.com.   IN      MX      10 mail.example.net.

www.example.com.       IN      A        XXX.XXX.XXX.XXX
www.example.com.       IN    AAAA    4001:41d0:1:4462::1
www       IN A          XXX.XXX.XXX.XXXCode language: PHP (php)

Ps: example.net est le domaine principal du serveur.

Pous vérifions la configuration BIND:

named-checkconf -z

et nous redémarrons BIND pour prendre en compte nos changements et activer notre nouveau fichier de zone:

service bind9 restart

Vous pouvez vérifier votre configuration DNS à l’aide de l’outil ZoneMaster.

Configuration du bloc serveur sous NginX

On commence par créer le répertoire qui va accueillir les fichiers du site et on lui attribue les bons droits:

mkdir -p /home/example/public_html
chown -R www-data:www-data /home/example/public_html
chmod 755 /home/example/public_html

On crée également un fichier index.php à la racine du site pour éviter une erreur 403 plus tard lors de la génération du certificat SSL :

echo "<!--?php echo 'hello world. Domain activated.'; ?-->" >> /home/example/public_html/index.phpCode language: HTML, XML (xml)

On crée maintenant le répertoire de cache du site, toujours avec les bons droits:

mkdir -p /home/nginx-cache/example
chown -R www-data:www-data /home/nginx-cache/example
chmod 755 /home/nginx-cache/example

Voici le server block de départ, en HTTP simple :

server {
       listen         80;
       listen    [::]:80;
       server_name    example.com www.example.com;
       #return         301 https://$server_name$request_uri;
        root /home/example/public_html;
        index index.php index.html;
}Code language: PHP (php)

On active le site :

ln -s /etc/nginx/sites-available/example.com /etc/nginx/sites-enabled/

On teste la configuration de NginX et on redémarre le service:

nginx -t
service nginx restart

On crée maintenant le certificat SSL avec Let’s Encrypt :

certbot certonly --webroot -w /home/example/public_html -d example.com -d www.example.com

On modifie maintenant tout le server block du domaine pour prendre en compte la configuration SSL. On redirige tous les requêtes HTTP vers HTTPS :

nano /etc/nginx/sites-available/example.com

# Virtual Host configuration for example.com

# https://deliciousbrains.com/hosting-wordpress-yourself-nginx-security-tweaks-woocommerce-caching-auto-server-updates/
fastcgi_cache_path /home/nginx-cache/example levels=1:2 keys_zone=example:100m inactive=60m max_size=256m;

# Expires map
map $sent_http_content_type $expires {
    default                    off;
    text/html                  epoch;
    text/css                   max;
    application/javascript     max;
    ~image/                    max;
}

server {
	listen 443 ssl http2;
	listen [::]:443 ssl http2;

	server_name example.com www.example.com;
	root /home/example/public_html;
 	index index.php index.html;

	ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
	ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;

	# security
	add_header Strict-Transport-Security "max-age=63072000; includeSubdomains; preload" always;
  	add_header X-Frame-Options SAMEORIGIN;
  	add_header X-Content-Type-Options nosniff;
	add_header X-XSS-Protection "1; mode=block";

add_header Content-Security-Policy "default-src 'self' https: data:  *.example.com; script-src 'self' https: data: https://stats.wp.com https://z-eu.amazon-adsystem.com https://ws-eu.assoc-amazon.com 'unsafe-inline' 'unsafe-eval'; style-src 'self' https: data: https://fonts.googleapis.com https://ws-eu.assoc-amazon.com 'unsafe-inline'; img-src 'self' https: data:; font-src 'self' https: data: * https://fonts.googleapis.com; media-src mediastream: *;";

        add_header Referrer-Policy "strict-origin-when-cross-origin";
	add_header X-Cache-Status $upstream_cache_status;

	# expiration
	expires $expires;

	# CACHE DIRECTIVES : $no_cache
	include snippets/cache.conf;

        # SERVE STATIC DIRECTLY
        include snippets/static.conf;

       location / {
		# WordPress Permalinks
                try_files $uri $uri/ /index.php?$args;
       }

	location ~ \.php$ {
		# https://www.garron.me/en/linux/your-own-cdn.html
		fastcgi_cache_bypass $no_cache;
                fastcgi_no_cache $no_cache;
                fastcgi_cache example;
                fastcgi_cache_valid 60m;
		fastcgi_cache_key $scheme$host$request_uri$request_method;
		fastcgi_cache_valid 200 301 302 5s;
		fastcgi_cache_use_stale updating error timeout invalid_header http_500 http_503;

		proxy_cache_revalidate on;
		proxy_cache_lock on;

		fastcgi_pass_header Set-Cookie;
		fastcgi_pass_header Cookie;
		fastcgi_ignore_headers Cache-Control Expires Set-Cookie;

		# fix error "upstream timed out (110: Connection timed out) 
		# while reading response header from upstream"
		fastcgi_read_timeout 120;

		fastcgi_pass unix:/run/php/php7.2-fpm.sock;
                include snippets/fastcgi-php.conf;
                include fastcgi_params;
    	}

	location ~ /purge(/.*) {
		fastcgi_cache_purge example "$scheme$request_method$host$1";
	}

    	location ~ /\.ht {
        	deny all;
    	}

	location = /favicon.ico { log_not_found off; access_log off; }
	location = /robots.txt { log_not_found off; access_log off; allow all; }
}

#
# REDIRECT HTTP TO HTTPS
#

server {
       listen         80;
       listen    [::]:80;
       server_name    example.com www.example.com;
       return         301 https://www.$server_name$request_uri;
	root /home/example/public_html;
        index index.php index.html;
}Code language: PHP (php)

On teste la configuration de NginX et on redémarre le service:

nginx -t
service nginx restart

Testez le site, vous devriez avoir votre page active et servie en HTTPS.

Vous pouvez également consultez l’article Serveur dédié : installer NginX avec support HTTP2 et certificat SSL, PHP, MariaDB sous Debian.

Récupération des fichiers du site chez l’ancien hébergeur

Dans une console SSH sur l’ancien serveur, on compresse le répertoire /www qui contient tous les fichiers du site en un seul fichier gzip:

date=`date -I`;
FILENAME="sitebackup_$date.tgz"
tar -zcvf $FILENAME wwwCode language: JavaScript (javascript)

Maintenant, ouvrez une nouvelle session SSH, sur le nouveau serveur et récupérez le fichier de sauvegarde avec scp dans le répertoire d’accueil, /home/example:

scp olduser@ftp.oldhosting.com:sitebackup_2018-01-27.tgz /home/example

On unzip notre fichier de sauvegarde:

tar -zxvf sitebackup_2018-01-27.tgzCode language: CSS (css)

et on déplace les fichiers qui se trouvent sous /www dans /public_html:

mv www/* public_html/

On réapplique les bons droits:

chown -R www-data:www-data /home/example/public_html
chmod 755 /home/example/public_html

Création de la base de données SQL

Sur le serveur, on se connecte au serveur de base de données:

mysql -u root -p

On crée la nouvelle base:

CREATE DATABASE xxxxxxxxxxxx DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci;Code language: PHP (php)

On crée l’utilisateur:

GRANT ALL ON xxxxxxxxxxxx.* TO 'm1s73rBE'@'localhost' IDENTIFIED BY 'y{6yW%djyW!171Pkc[577$';

Code language: JavaScript (javascript)

On sauvegarde et on quitte:

FLUSH PRIVILEGES;
exit;Code language: PHP (php)

Il ne vous reste plus qu’à importer l’ancienne base de données dans celle que vous venez de créer.

A ce stade, le domaine pointe vers le serveur, la base de données est active et les fichiers sont servis par NginX et PHP. Passons à la configuration email.

Configuration d’OpenDKIM pour signer et authentifier le courrier sortant

Le nouveau domaine va utiliser notre serveur email en Perfect Forward Secrecy avec TLS. Par défaut, les emails ne seront ni signés, ni authentifiés (point d’interrogation sur l’icône de l’expéditeur dans Gmail par exemple).

Pour signer et authentifier le courrier sortant, il suffit d’ajouter le domaine dans la configuration d’opendkim. Cela ne prend que quelques minutes.

1. On crée le répertoire de travail et on génère une clé de 4096 bits que l’on renomme mail:

mkdir -pv /etc/opendkim/example.com
cd /etc/opendkim/example.com
opendkim-genkey -r -h rsa-sha256 -d example.com -s mail -b 4096
mv -v mail.private mailCode language: PHP (php)

2. On donne les droits à opendkim:opendkim :

chown -Rv opendkim:opendkim /etc/opendkim
chmod go-rwx /etc/opendkim/*

3. On récupère la clé publique :

cat mail.txtCode language: CSS (css)

4. Copiez le contenu du fichier. Nous allons ajouter cet enregistrement à notre fichier de zone bind9:

nano /etc/bind/example.com.hosts

On en profite pour ajouter SPF tant qu’on y est, ce qui nous donne:

;SPF
example.com. IN TXT "v=spf1 ip4:XXX.XXX.XXX.XXX mx -all"
example.com. IN SPF "v=spf1 ip4:XXX.XXX.XXX.XXX mx -all"

;DKIM
_domainkey.example.com. IN TXT "t=y; o=-;"
_adsp._domainkey.example.com. IN TXT "dkim=unknown"
mail._domainkey	IN	TXT	( "v=DKIM1; h=rsa-sha256; k=rsa; s=email; "
	  "p=MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEApBie0lc4TsGc9xhlyoFvVGvV+gLUmjxFz8GB92/sg7EhGA91fPXoPLfN5Ci4hANUDdYezTnAhyO/bGp44OE2/98f/81EO3IoaK6E+Qwt8qQIjZvxO4KY2LQ6Ld1EaQUQBr73Gzvw2WuBgKy3/rwGyTHvFjTrw+2rt1alssCbyDqoWklVv3PdVmbnzkoTG3Zn/mDnhhKBOJAcbT"
	  "NG9LR7tlwwid0apgEPCt4DKeGpmMad+F3IiHJuojUfeJbFSd2QrgBIutz1Oh1e9JiwEM3zrBhn3FBTK6GzhcOMp9C8YLZusqlAYAdN+3CpGDBX/b6L+ILodn4VGdvMIvaclaxIMG31FazesT5G0VuNaGzmDp95SVWlhT4crXVgZcF3CY4RY933mVQeLPffP3nqtsxP3pGkSb4nmSEfHxXCRoC8wZ2hKYpltGqT3wqpc/+QtqIOokkhxaOF"
	  "axw7UcN8+NsKW5W1WSt3vY3O+l84b2dJYbHSKWue4i+uEJR+CF4SpeZORBSSgwHShAmkVIopmreFkn6Ooa+iujusyChpc4ASuwaZ+LXphvphIzPZcpjUYQYrNqOqkg5veC2otO0cb8v42KA7OaCuyZcLx1BhbkSRvDnniY/v14ZSQquw84Y2KDY+lH2lAMOhlDOZwdsKoBASnxp+lmuxzVK97/AzS3zUt50CAwEAAQ==" )  ; ----- DKIM key mail for example.comCode language: JavaScript (javascript)

N’oubliez pas d’incrémenter le numéro de série du fichier de zone et sauvegardez le fichier.

5. On ajoute notre domaine à nos tables de clé tout d’abord:

nano /etc/opendkim/KeyTable

et on y ajoute, sur une nouvelle ligne:

example.com example.com:mail:/etc/opendkim/example.com/mailCode language: JavaScript (javascript)

On fait de même avec la table de signatures:

nano /etc/opendkim/SigningTable

et on y ajoute, sur une nouvelle ligne:

*@example.com example.comCode language: CSS (css)

6. On relance les services :

service bind9 restart && service opendkim restart && service postfix restart

Voilà, votre courrier est désormais signé et authentifié pour ce domaine.

Conclusion

Vous avez donc récupéré une archive de votre ancien site, créé un nouvel espace d’accueil sur le serveur (fichiers et bases de données), servi le tout en HTTPS et configuré le serveur de mail pour authentifier et signer tout le courrier sortant.

Articles conseillés :

• 8 règles d’or pour bien déployer DNSSEC et DANE
• Serveur dédié : mettre en place DNSSEC pour sécuriser les DNS du domaine
• Serveur dédié : ajouter l’authentification SPF, Sender-ID et DKIM à Postfix et Bind9 avec opendkim
• Serveur dédié : mise en place du protocole DANE
• Serveur dédié : produire une meilleure réserve d’entropie avec haveged
• Serveur dédié : configurer Postfix et Courier pour utiliser TLS-SSL en Perfect Forward Secrecy