Commit bf7626c8 authored by Leia's avatar Leia

Add French translation

parent e77709b7
......@@ -17,6 +17,36 @@ enableGitInfo = true
contentDir = "content/pl"
languageName = "Polski"
weight = 1
[languages.fr]
contentDir = "content/fr"
languageName = "Français"
weight = 1
[languages.fr.menu]
[[languages.fr.menu.docs]]
name = "Guide d'utilisation"
weight = 1
identifier = "usage"
url = "/usage/"
[[languages.fr.menu.docs]]
name = "Guide d'administration"
weight = 2
identifier = "administration"
url = "/administration/"
[[languages.fr.menu.docs]]
name = "Guide de développement"
weight = 3
identifier = "development"
url = "/development/"
[[languages.fr.menu.docs]]
name = "Aperçu de l'API"
weight = 4
identifier = "api"
url = "/api/"
[[languages.fr.menu.docs]]
name = "API REST"
weight = 5
identifier = "rest-api"
url = "/api/rest/"
[menu]
[[menu.docs]]
......
---
title: Documentation de Mastodon
---
Bienvenue dans la documentation de Mastodon !
<div style="margin-bottom: 26px">
{{< youtube "IPSbNdBmWKE" >}}
</div>
**Choisissez ce que vous voulez voir aujourd'hui :**
- [Apprendre à se servir de Mastodon]({{< relref "usage/basics.md" >}})
- [Apprendre à installer Mastodon]({{< relref "administration/installation.md" >}})
- [Apprendre à coder une application pour Mastodon]({{< relref "api/guidelines.md" >}})
---
title: Configuration
description: Vue d'ensemble des options de configuration de Mastodon
menu:
docs:
parent: administration
weight: 2
---
Mastodon utilise des variables d'environnement pour sa configuration.
Par commodité, Mastodon lit ces variables depuis un fichier texte nommé `.env.production` dans le dossier contenant Mastodon, mais elles peuvent toujours être outrepassées par un processus. Par exemple, les fichiers de service systemd peuvent lire des variables d'environnement depuis un `EnvironmentFile` ou des variables définies avec `Environment` dans le fichier de service directement, pour que vous puissiez avoir plusieurs configurations pour des services spécifiques. Ces variables peuvent aussi être définies quand Mastodon est exécuté depuis la ligne de commande.
## Basique
### Fédération
- `LOCAL_DOMAIN`
- `WEB_DOMAIN`
- `ALTERNATE_DOMAINS`
### Secrets
- `SECRET_KEY_BASE`
- `OTP_SECRET`
- `VAPID_PRIVATE_KEY`
- `VAPID_PUBLIC_KEY`
### Déploiement
- `RAILS_ENV`
- `RAILS_SERVE_STATIC_FILES`
- `RAILS_LOG_LEVEL`
- `TRUSTED_PROXY_IP`
- `SOCKET`
- `PORT`
- `NODE_ENV`
- `BIND`
### Options pour l'aménagement des ressources
- `WEB_CONCURRENCY`
- `MAX_THREADS`
- `PREPARED_STATEMENTS`
- `STREAMING_API_BASE_URL`
- `STREAMING_CLUSTER_NUM`
## Connexion aux bases de données
### PostgreSQL
- `DB_HOST`
- `DB_USER`
- `DB_NAME`
- `DB_PASS`
- `DB_PORT`
- `DATABASE_URL`
### Redis
- `REDIS_HOST`
- `REDIS_PORT`
- `REDIS_URL`
- `REDIS_NAMESPACE`
- `CACHE_REDIS_HOST`
- `CACHE_REDIS_PORT`
- `CACHE_REDIS_URL`
- `CACHE_REDIS_NAMESPACE`
### ElasticSearch
- `ES_ENABLED`
- `ES_HOST`
- `ES_PORT`
- `ES_PREFIX`
### StatsD
- `STATSD_ADDR`
- `STATSD_NAMESPACE`
## Limites
- `SINGLE_USER_MODE`
- `EMAIL_DOMAIN_WHITELIST`
- `DEFAULT_LOCALE`
- `MAX_SESSION_ACTIVATIONS`
- `USER_ACTIVE_DAYS`
## E-mail
- `SMTP_SERVER`
- `SMTP_PORT`
- `SMTP_LOGIN`
- `SMTP_PASSWORD`
- `SMTP_FROM_ADDRESS`
- `SMTP_DOMAIN`
- `SMTP_DELIVERY_METHOD`
- `SMTP_AUTH_METHOD`
- `SMTP_CA_FILE`
- `SMTP_OPENSSL_VERIFY_MODE`
- `SMTP_ENABLE_STARTTLS_AUTO`
- `SMTP_TLS`
## Stockage distant des fichiers
- `CDN_HOST`
- `S3_ALIAS_HOST`
### Stockage local des fichiers
- `PAPERCLIP_ROOT_PATH`
- `PAPERCLIP_ROOT_URL`
### Amazon S3 et compatibles
- `S3_ENABLED`
- `S3_BUCKET`
- `AWS_ACCESS_KEY_ID`
- `AWS_SECRET_ACCESS_KEY`
- `S3_REGION`
- `S3_PROTOCOL`
- `S3_HOSTNAME`
- `S3_ENDPOINT`
- `S3_SIGNATURE_VERSION`
### Swift
- `SWIFT_ENABLED`
- `SWIFT_USERNAME`
- `SWIFT_TENANT`
- `SWIFT_PASSWORD`
- `SWIFT_PROJECT_ID`
- `SWIFT_AUTH_URL`
- `SWIFT_CONTAINER`
- `SWIFT_OBJECT_URL`
- `SWIFT_REGION`
- `SWIFT_DOMAIN_NAME`
- `SWIFT_CACHE_TTL`
## Authentification externe
- `OAUTH_REDIRECT_AT_SIGN_IN`
### LDAP
- `LDAP_ENABLED`
- `LDAP_HOST`
- `LDAP_PORT`
- `LDAP_METHOD`
- `LDAP_BASE`
- `LDAP_BIND_DN`
- `LDAP_PASSWORD`
- `LDAP_UID`
- `LDAP_SEARCH_FILTER`
### PAM
- `PAM_ENABLED`
- `PAM_EMAIL_DOMAIN`
- `PAM_DEFAULT_SERVICE`
- `PAM_CONTROLLED_SERVICE`
### CAS
- `CAS_ENABLED`
- `CAS_URL`
- `CAS_HOST`
- `CAS_PORT`
- `CAS_SSL`
- `CAS_VALIDATE_URL`
- `CAS_CALLBACK_URL`
- `CAS_LOGOUT_URL`
- `CAS_LOGIN_URL`
- `CAS_UID_FIELD`
- `CAS_CA_PATH`
- `CAS_DISABLE_SSL_VERIFICATION`
- `CAS_UID_KEY`
- `CAS_NAME_KEY`
- `CAS_EMAIL_KEY`
- `CAS_NICKNAME_KEY`
- `CAS_FIRST_NAME_KEY`
- `CAS_LAST_NAME_KEY`
- `CAS_LOCATION_KEY`
- `CAS_IMAGE_KEY`
- `CAS_PHONE_KEY`
### SAML
- `SAML_ENABLED`
- `SAML_ACS_URL`
- `SAML_ISSUER`
- `SAML_IDP_SSO_TARGET_URL`
- `SAML_IDP_CERT`
- `SAML_IDP_CERT_FINGERPRINT`
- `SAML_NAME_IDENTIFIER_FORMAT`
- `SAML_CERT`
- `SAML_PRIVATE_KEY`
- `SAML_SECURITY_WANT_ASSERTION_SIGNED`
- `SAML_SECURITY_WANT_ASSERTION_ENCRYPTED`
- `SAML_SECURITY_ASSUME_EMAIL_IS_VERIFIED`
- `SAML_ATTRIBUTES_STATEMENTS_UID`
- `SAML_ATTRIBUTES_STATEMENTS_EMAIL`
- `SAML_ATTRIBUTES_STATEMENTS_FULL_NAME`
- `SAML_ATTRIBUTES_STATEMENTS_FIRST_NAME`
- `SAML_ATTRIBUTES_STATEMENTS_LAST_NAME`
- `SAML_UID_ATTRIBUTE`
- `SAML_ATTRIBUTES_STATEMENTS_VERIFIED`
- `SAML_ATTRIBUTES_STATEMENTS_VERIFIED_EMAIL`
## Services cachés (Tor)
- `http_proxy`
- `ALLOW_ACCESS_TO_HIDDEN_SERVICE`
## Autres
- `SKIP_POST_DEPLOYMENT_MIGRATIONS`
---
title: Installation
description: Comment installer Mastodon sur un serveur Ubuntu 18.04
menu:
docs:
parent: administration
weight: 1
---
<img src="/setup.png" alt="" style="margin: 0; box-shadow: none">
## Configuration basique du serveur (facultatif)
Si vous configurez une nouvelle machine, il est recommandé de la sécuriser en premier lieu. En supposant que vous utilisez **Ubuntu 18.04** :
### Refuser les connections SSH par mot de passe (clés uniquement)
Assurez-vous tout d'abord que vous actuellement connecté à votre serveur en utilisant une clé SSH et non avec un mot de passe, sinon vous serez bloqué. La plupart des hébergeurs supportent l'envoi d'une clé SSH publique et configurent automatiquement la connexion à l'utilisateur root sur votre nouveau serveur via votre clé.
Ouvrez `/etc/ssh/sshd_config` et cherchez `PasswordAuthentication`. Assurez-vous que la ligne n'est pas commentée et qu'elle est réglée sur `no`. Si vous avez apporté des modifications au fichier, redémarrez sshd :
```sh
systemctl restart ssh
```
### Mettre à jour le système
```sh
apt update && apt upgrade -y
```
### Installer fail2ban pour bloquer les tentatives de connexion répétées
```sh
apt install fail2ban
```
Ouvrez `/etc/fail2ban/jail.local` et copiez-collez ceci à l'intérieur :
```ini
[DEFAULT]
destemail = votre@adresse_mail.ici
sendername = Fail2Ban
[sshd]
enabled = true
port = 22
[sshd-ddos]
enabled = true
port = 22
```
Enfin, redémarrez fail2ban :
```sh
systemctl restart fail2ban
```
### Installer un pare-feu et mettre uniquement sur liste blanche les ports SSH, HTTP et HTTPS
D'abord, installez iptables-persistent. Durant l'installation, il vous sera demandé si vous voulez conserver les directives actuelles--refusez.
```sh
apt install -y iptables-persistent
```
Ouvrez `/etc/iptables/rules.v4` et copiez-collez ceci à l'intérieur :
```
*filter
# Autoriser tout trafic sur la boucle locale (lo0) et refuser tout trafic vers 127/8 qui n'utilise pas lo0
-A INPUT -i lo -j ACCEPT
-A INPUT ! -i lo -d 127.0.0.0/8 -j REJECT
# Autoriser toutes les connexions entrantes établies
-A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
# Autoriser tout le trafic sortan - vous pouvez modifier cette ligne pour n'autoriser qu'un certain type de trafic
-A OUTPUT -j ACCEPT
# Autoriser les connexions HTTP et HTTPS de n'importe où (via les ports habituels pour les sites web et SSL)
-A INPUT -p tcp --dport 80 -j ACCEPT
-A INPUT -p tcp --dport 443 -j ACCEPT
# Autoriser les connexions SSH
# Le nombre juste après -dport doit être le même que celui défini dans sshd_config
-A INPUT -p tcp -m state --state NEW --dport 22 -j ACCEPT
# Autoriser le ping
-A INPUT -p icmp -m icmp --icmp-type 8 -j ACCEPT
# Enregistrer les accès refusés par iptables
-A INPUT -m limit --limit 5/min -j LOG --log-prefix "iptables denied: " --log-level 7
# Rejeter toutes les autres connexions entrantes - par défaut, refuser tout ce qui n'est pas défini explicitement par la directive ALLOW
-A INPUT -j REJECT
-A FORWARD -j REJECT
COMMIT
```
Avec iptables-persistent, cette configuration sera chargée à chaque redémarrage. Mais puisque nous n'allons pas redémarrer tout de suite, nous devons la charger manuellement pour cette fois :
```sh
iptables-restore < /etc/iptables/rules.v4
```
## Pré-requis
- Une machine exécutant **Ubuntu 18.04** sur laquelle vous avez un accès root
- Un **nom de domaine** (ou un sous-domaine) pour l'instance Mastodon, ex. `exemple.com`
- Un service d'envoi de courriel ou autre **serveur SMTP**
Vous exécuterez les commandes suivantes en tant qu'utilisateur root sur le serveur. Si vous n'êtes pas encore root, identifiez-vous :
```sh
sudo -i
```
### Dépôts de paquets système
Assurez-vous que curl est installé :
```sh
apt install -y curl
```
#### Node.js
```sh
curl -sL https://deb.nodesource.com/setup_8.x | bash -
```
#### Yarn
```sh
curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add -
echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list
```
### Paquets système
```sh
apt update
apt install -y \
imagemagick ffmpeg libpq-dev libxml2-dev libxslt1-dev file git-core \
g++ libprotobuf-dev protobuf-compiler pkg-config nodejs gcc autoconf \
bison build-essential libssl-dev libyaml-dev libreadline6-dev \
zlib1g-dev libncurses5-dev libffi-dev libgdbm5 libgdbm-dev \
nginx redis-server redis-tools postgresql postgresql-contrib \
certbot yarn libidn11-dev libicu-dev libjemalloc-dev
```
### Installation de Ruby
Nous utiliserons rbenv pour gérer les différentes versions de Ruby, car c'est plus facile pour récupérer les bonnes versions et se mettre à jour quand une nouvelle version est publiée. rbenv doit être installé pour qu'un seul utilisateur, nous devons donc créer le compte utilisateur que Mastodon utilisera par la suite :
```sh
adduser --disabled-login mastodon
```
Nous pouvons ensuite nous identifier :
```sh
su - mastodon
```
Et procéder à l'installation de rbenv et rbenv-build:
```sh
git clone https://github.com/rbenv/rbenv.git ~/.rbenv
cd ~/.rbenv && src/configure && make -C src
echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bashrc
echo 'eval "$(rbenv init -)"' >> ~/.bashrc
exec bash
git clone https://github.com/rbenv/ruby-build.git ~/.rbenv/plugins/ruby-build
```
Une fois ceci fait, nous pouvons installer la bonne version de Ruby :
```sh
RUBY_CONFIGURE_OPTS=--with-jemalloc rbenv install 2.6.1
rbenv global 2.6.1
```
La version de gem fournie par défaut avec ruby_2.6.1 est incompatible avec la dernière version de bundler, nous devons donc mettre à jour gem :
```
gem update --system
```
Nous aurons aussi besoin d'installer bundler :
```sh
gem install bundler --no-document
```
Retournez sur root :
```sh
exit
```
## Configuration
### Mettre en place PostgreSQL
#### Configurer pour des performances optimales (facultatif)
Pour obtenir des performances optimales, vous pourriez utiliser [pgTune](https://pgtune.leopard.in.ua/#/) afin de générer une configuration adéquate et modifier les valeurs si nécessaire dans `/etc/postgresql/9.6/main/postgresql.conf` avant de redémarrer PostgreSQL avec `systemctl restart postgresql`
#### Créer un utilisateur
Vous devez créer un utilisateur PostgreSQL que Mastodon pourra utiliser. Il est plus facile de partir sur une authentification "ident" dans une configuration basique, c-à-d que l'utilisateur PostgreSQL n'a pas un mot de passe différent et peut être utilisé par l'utilisateur Linux portant le même nom.
Accédez à l'interface PostgreSQL :
```sh
sudo -u postgres psql
```
Là, exécutez ceci :
```
CREATE USER mastodon CREATEDB;
\q
```
C'est fait !
### Mettre en place Mastodon
C'est le moment de télécharger le code source de Mastodon. Connectez-vous à l'utilisateur mastodon :
```sh
su - mastodon
```
#### Récupérer le code
Utilisez git pour télécharger la dernière version stable de Mastodon :
```sh
git clone https://github.com/tootsuite/mastodon.git live && cd live
git checkout $(git tag -l | grep -v 'rc[0-9]*$' | sort -V | tail -n 1)
```
#### Installer les dernières dépendances
Maintenant, installez les dépendances Ruby et JavaScript :
```sh
bundle install \
-j$(getconf _NPROCESSORS_ONLN) \
--deployment --without development test
yarn install --pure-lockfile
```
#### Générer un fichier de configuration
Lancez l'assistant de configuration interactif :
```sh
RAILS_ENV=production bundle exec rake mastodon:setup
```
L'assistant va :
- Créer un fichier de configuration
- Compiler les ressources web
- Créer la base de données
Le fichier de configuration est enregistré sous le nom de `.env.production`. Vous pouvez le relire et le modifier à votre guise. Référez-vous à la [page de documentation]({{< relref "configuration.md" >}}) à ce sujet.
Nous en avons fini avec l'utilisateur mastodon, pour l'heure, passez à nouveau sur root :
```sh
exit
```
### Mettre en place nginx
Copiez le modèle de configuration pour nginx depuis le dossier contenant Mastodon :
```sh
cp /home/mastodon/live/dist/nginx.conf /etc/nginx/sites-available/mastodon
ln -s /etc/nginx/sites-available/mastodon /etc/nginx/sites-enabled/mastodon
```
Modifiez `/etc/nginx/sites-available/mastodon` pour remplacer `example.com` par votre propre nom de domaine, et apportez les autres modifications que vous auriez à faire.
Rechargez nginx pour que les modifications soient prises en compte :
```sh
systemctl reload nginx
```
### Obtenir un certificat SSL
Nous utiliserons Let's Encrypt pour obtenir un certificat SSL gratuitement :
```sh
certbot certonly --webroot -d example.com -w /home/mastodon/live/public/
```
Modifiez `/etc/nginx/sites-available/mastodon` pour dé-commenter et adapter à votre cas les lignes `ssl_certificate` et `ssl_certificate_key`.
Enfin, rechargez nginx pour que les modifications soient prises en compte :
```sh
systemctl reload nginx
```
Vous devriez pouvoir désormais visiter votre domaine dans un navigateur web et voir l'éléphant frappant l'ordinateur avec un message d'erreur. C'est parce que nous n'avons pas encore démarré le processus Mastodon.
### Mettre en place les services systemd
Copiez les modèles de fichiers service systemd depuis le dossier contenant Mastodon :
```sh
cp /home/mastodon/live/dist/mastodon-*.service /etc/systemd/system/
```
Ouvrez les fichiers et assurez-vous que le nom d'utilisateur et les chemins d'accès sont corrects :
- `/etc/systemd/system/mastodon-web.service`
- `/etc/systemd/system/mastodon-sidekiq.service`
- `/etc/systemd/system/mastodon-streaming.service`
Enfin, démarrez et activez les nouveaux services systemd :
```sh
systemctl start mastodon-web mastodon-sidekiq mastodon-streaming
systemctl enable mastodon-*
```
Ils démarreront automatiquement à chaque redémarrage de la machine.
**Hourra ! C'est enfin fini. Vous pouvez accéder à votre instance depuis votre navigateur !**
---
title: Migration de serveur
description: Comment migrer une instance Mastodon sur un nouveau serveur
menu:
docs:
parent: administration
weight: 6
---
Parfois, pour des raisons diverses, vous avez besoin de migrer votre instance Mastodon d'un serveur à un autre. Heureusement, ce n'est pas une opération trop complexe, même si ça peut résulter en un petit temps où l'instance n'est pas utilisable.
**Note :** ce guide a été écrit avec l'utilisation d'Ubuntu Server en tête ; certaines opérations peuvent différer si vous utilisez un autre système d'exploitation.
Étapes basiques
----
1. Créez une nouvelle instance Mastodon en utilisant le [guide d'installation](/administration/installation/) (mais n'exécutez pas `mastodon:setup`).
2. Arrêtez Mastodon sur l'ancien serveur (par ex. `systemctl stop 'mastodon-*.service'`).
3. Sauvegardez et chargez la base de données PostgreSQL en suivant les instructions plus bas.
4. Copier les fichiers du dossier `system/` en suivant les instructions plus bas. (Note : si vous utilisez S3, vous pouvez passer cette étape.)
5. Copiez le fichier `.env.production`.
6. Exécutez `RAILS_ENV=production ./bin/tootctl feeds build` pour reconstruire les timelines personnelles de chaque utilisateur·ice.
7. Démarrez Mastodon sur le nouveau serveur.
8. Mettez à jour la zone DNS pour qu'elle pointe sur le nouveau serveur.
9. Mettez à jour ou copiez votre configuration Nginx, ré-exécutez LetsEncrypt si nécessaire.
10. Profitez de votre nouveau serveur !
Étapes détaillées
----
### Quelles données doivent être migrées
Prioritairement, vous devez copier ceci :
- Le dossier `~/live/public/system`, qui contient les photos et vidéos téléversées par les utilisateur·ice·s (si vous utilisez S3, vous n'avez pas à le faire)
- La base de données PostgreSQL (en utilisant [pg\_dump](https://www.postgresql.org/docs/9.1/static/backup-dump.html))
- Le fichier `~/live/.env.production`, qui contient la configuration de l'instance et ses variables secrètes
Moins important, vous voudrez probablement copier ces fichiers pour plus de commodité :
- La configuration nginx (sous `/etc/nginx/sites-available/default`)
- Les fichiers de services systemd (`/etc/systemd/system/mastodon-*.service`), qui peuvent contenir des modifications spécifiques à votre instance
- La configuration PgBouncer dans `/etc/pgbouncer` (si vous l'utilisez)
### Sauvegarder et charger PostgreSQL
Au lieu d'exécuter `mastodon:setup`, on va créer une base de données PostgreSQL vide
en utilisant la base de données `template0` (qui est utile quand on restaure une sauvegarde PostgreSQL,
[comme détaillé dans la documentation de pg\_dump](https://www.postgresql.org/docs/9.1/static/backup-dump.html#BACKUP-DUMP-RESTORE)).
Exécutez ceci en tant qu'utilisateur `mastodon` sur l'ancien serveur :
```bash
pg_dump -Fc mastodon_production -f backup.dump
```
Copiez le fichier `backup.dump` sur le nouveau serveur, en utilisant `rsync` ou `scp`. Puis, sur le nouveau serveur,
créez une base de données vide en tant qu'utilisateur `mastodon` :
```bash
createdb -T template0 mastodon_production
```
Et importez-la :
```bash
pg_restore -U mastodon -n public --no-owner --role=mastodon \
-d mastodon_production backup.dump
```
(Notez que si le nom d'utilisateur sur le nouveau serveur n'est pas `mastodon`, vous devriez changer les valeurs de
`-U` AND `--role` dans la commande juste au-dessus. C'est pas grave si le nom d'utilisateur est différent entre les deux serveurs.)
### Copier les fichiers
Cela va sûrement prendre du temps, et vous voudrez sûrement éviter de recopier des fichiers inutilement, utiliser `rsync` est donc recommandé.
Sur l'ancien serveur, en tant qu'utilisateur `mastodon`, faites :
```bash
rsync -avz ~/live/public/system/ mastodon@exemple.fr:~/live/public/system/
```
Vous répèterez l'opération si jamais les fichiers sur l'ancien serveur devaient changer.
Vous devriez copier le fichier `.env.production`, qui contient des secrets nécessaires à l'instance.
Optionnellement, vous pouvez copier les fichiers de configuration nginx, systemd, et pgbouncer, ou les réécrire de zéro.
### Durant la migration
Vous pouvez modifier le fichier `~/live/public/500.html` sur l'ancien serveur si vous voulez afficher un joli message d'erreur et permettre de faire savoir aux utilisateur·ice·s qu'une migration est en cours.
Vous voudrez probablement modifier le TTL DNS pour quelque chose de plus petit (30 à 60 minutes) un jour à l'avance, la propagation DNS se fera ainsi plus rapidement quand vous aurez indiqué la nouvelle adresse IP.
### Après la migration
Vous pouvez aller sur [whatsmydns.net](http://whatsmydns.net/) pour voir la progression de la propagation DNS.
Pour ne pas attendre, vous pouvez toujours modifier votre propre fichier `/etc/hosts` pour pointer vers votre nouveau serveur et donc commencer à vous amuser avec avant les autres.
---
title: Fonctionnalités facultatives
description: Comment activer les fonctionnalités facultatives de Mastodon
menu:
docs:
parent: administration
weight: 5
---
## Recherche plein-texte
Mastodon supporte la recherche plein-texte quand ElasticSearch est disponible. La recherche plein-texte permet aux utilisateur·ice·s connecté·e·s de chercher dans leurs propres pouets, favoris et mentions. Cependant, la recherche plein-texte empêche délibérément de chercher arbitrairement dans toute la base de données.
### Installer ElasticSearch
ElasticSearch requiert un environnement java. Si vous n'avez pas Java d'installé, faites-le maintenant. En supposant que vous êtes connecté en `root` :
apt install openjdk-8-jre-headless
Ajoutez le dépôt logiciel officiel d'ElasticSearch :