L’objectif de ce post est simple. Il s’agit d’héberger une application Symfony v6.3 dans un téléphone Android. On installera les différents outils nécessaires au bon fonctionnement de cette application : nginx, php, php-fpm. On utilisera ensuite FRP (Fast Reverse Proxy) pour créer un tunnel, afin d’exposer le site local sur Internet. Si vous connaissez ngrok, FRP est une alternative gratuite et open source à ngrok.

Pré-requis

Voici les différents outils qu’on va utiliser :

Un téléphone Nokia 2 – modèle TA-1029, avec une capacité du disque dur à 8 go, dans lequel tourne un Android version 7.1.
L’application termux en version 0.118.0.
Un serveur linux accessible en SSH.
Un nom de domaine – https://mrok.miary.dev/ qui pointe vers l’adresse IP du serveur linux : 192.99.160.149

Installation des outils dans termux

Sur le téléphone, on lance l’application termux et on execute les commandes ci-dessous, une fois à l’intérieur du shell.

Update & Upgrade

On met à jour la liste des paquets disponibles et tous les paquets du système à leurs dernières versions disponibles.

pkg update
pkg upgrade

Installation des packages

On installe ensuite les différents packages dont on a besoin, tels que : php, php-fpm, nginx, git, nodejs-lts, vim, wget, neovim, curl…

pkg install openssh unzip
pkg install php php-fpm
pkg install nginx
pkg install nodejs-lts
pkg install git neovim wget curl fish neofetch
pkg install nmap

Adresse IP du téléphone dans le réseau

Dans le but de pouvoir se connecter en SSH, on va d’abord afficher les paramètres d’un réseau pour une interface réseau sans fil. On execute la commande :

ifconfig wlan0

Ce qui donnera comme retour

wlan0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1440
        inet 192.168.1.103  netmask 255.255.255.0  broadcast 192.168.1.255
        inet6 fe80::6ec4:d5ff:fe54:cc8  prefixlen 64  scopeid 0x20<link>
        inet6 2a01:e0a:1e7:30e0:6ec4:d5ff:fe54:cc8  prefixlen 64  scopeid 0x0<global>
        inet6 2a01:e0a:1e7:30e0:a442:eb62:d1f7:a97c  prefixlen 64  scopeid 0x0<global>
        unspec 00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00  txqueuelen 1000  (UNSPEC)
        RX packets 2819  bytes 1783024 (1.7 MiB)
        RX errors 0  dropped 2  overruns 0  frame 0
        TX packets 2231  bytes 496160 (484.5 KiB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

L’adresse IP qui nous intéresse ici est la suivante 192.168.1.103.

Mot de passe de session

On va spécifier un mot de passe pour l’utilisateur dans termux, pour pouvoir se connecter en SSH par la suite depuis un autre ordinateur. En ce qui me concerne, l’utilisateur est le suivant : u0_a130.

Pour choisir ou modifier le mot de passe de cet utilisateur, on execute la commande :

passwd

qui va demander de choisir le mot de passe et ensuite de le re-confirmer , et enfin de l’enregistrer.

sshd

On lance sshd, le daemon de SSH, qui écoute les connexions entrantes de clients SSH sur le port 22.

sshd

Connexion SSH à termux

A partir d’ici, on n’est plus obligé d’executer les commandes dans le téléphone. J’avoue que c’est plus confortable de taper des commandes avec un clavier d’ordinateur.

Depuis une autre machine, on se connecte à termux en executant la commande suivante :

ssh -p 8022 u0_a130@192.168.1.103

Le mot de passe spécifié plus haut sera alors demandé.

Démarrage du serveur NGINX

On execute la commande suivante pour démarrer nginx

nginx

A partir d’ici, si on ouvre un navigateur, et qu’on va sur http://192.168.1.103:8080 on est sensé avoir la page d’accueil par défaut de nginx (Cela fonctionne correctement, à condition d’être sur le même réseau)

Démarrage de php-fpm

On execute la commande suivante pour démarrer php-fpm

php-fpm

Faire fonctionner php-fpm et nginx ensemble

Pour cela, on modifie le fichier

vi /data/data/com.termux/files/usr/etc/nginx/nginx.conf

et on remplace tout le contenu par :

worker_processes 1;

events {
worker_connections 1024;
}

http {
include /data/data/com.termux/files/usr/etc/nginx/mime.types;
default_type application/octet-stream;

access_log  /data/data/com.termux/files/usr/var/log/nginx/access.log;
error_log   /data/data/com.termux/files/usr/var/log/nginx/error.log;

sendfile        on;
keepalive_timeout  65;

server {
    listen       8080;
    server_name  localhost;

    location / {
        root   /data/data/com.termux/files/usr/share/nginx/html/public;
        index  index.php index.html index.htm;
    }

    error_page   500 502 503 504  /50x.html;
    location = /50x.html {
        root   /data/data/com.termux/files/usr/share/nginx/html/public;
    }

    location ~ \.php$ {
        root           /data/data/com.termux/files/usr/share/nginx/html/public;
    fastcgi_pass   unix:/data/data/com.termux/files/usr/var/run/php-fpm.sock;       
        fastcgi_index  index.php;
        fastcgi_param  SCRIPT_FILENAME  $document_root$fastcgi_script_name;
        include        /data/data/com.termux/files/usr/etc/nginx/fastcgi_params;
    }
}

}

On enregistre les modifications. On stop nginx et on le redémarre avec les commandes

nginx -s stop
nginx

Installation de composer

On a besoin de composer pour installer Symfony et aussi le maker-bundle qu’on verra un peu plus bas.

La commande suivante permet d’installer composer et de déplacer le binaire dans le dossier usr/bin

curl -sS https://getcomposer.org/installer | php
mv composer.phar ../usr/bin/composer
chmod +x ../usr/bin/composer

Installation de Symfony

On installe ensuite la version 6.3 de Symfony, dans le dossier /data/data/com.termux/files/usr/share/nginx/html

On se rend dans le dossier /data/data/com.termux/files/usr/share/nginx/. On supprime le dossier html créé par défaut par nginx lors de son installation. On installe ensuite Symfony.

cd /data/data/com.termux/files/usr/share/nginx/
rm -rf html
mkdir html
composer create-project symfony/skeleton:"6.3.*" html
cd html
composer require webapp

On en profite pour installer maker-bundle pour pouvoir créer rapidement un HomeController.

cd html
composer require symfony/maker-bundle --dev

A partir de là, il nous est possible de créer notre premier controlleur, qui sera également la page d’accueil par défaut du site.

php bin/console make:controller Home

Au passage, la version de php installée est la php8.1

Pour que ce controller qui vient d’être créé, soit la page par défaut du site, on va aller modifier le fichier et changer la route.

vi src/Controller/HomeController.php

Et on remplace la ligne #[Route()] par

#[Route('/', name: 'app_home')]

A partir d’ici, quand on actualise l’URL http://192.168.1.103:8080, on doit avoir la page du controlleur qui s’affiche.

FRP (ngrok open source)

On utilise FRP (Fast Reverse Proxy) https://github.com/fatedier/frp , un outil Open source pour servir de tunnel, afin d’exposer notre site local dans termux sur Internet. Si vous connaissez ngrok, c’est exactement le même principe, et c’est totalement gratuit et open source.

On utilisera aussi notre propre domaine qui pointe vers l’adresse IP de notre serveur linux. Comme ça, lorsqu’on ira sur l’URL de notre nom de domaine, on affichera l’application Symfony hébergée sur notre téléphone.

DNS

On crée une entrée DNS de type A qui aura pour cible l’adresse IP du serveur 192.99.160.149. Le domaine utilisé sera le suivant : mrok.miary.dev,

Création de certificats letsencrypt.

On se connecte en SSH cette fois-ci sur le serveur Linux, qui possède l’adresse IP 192.99.160.149.

On va créer un certificat letsencrypt pour notre sous-domaine mrok.miary.dev

sudo certbot certonly --webroot --webroot-path /var/www/html -d mrok.miary.dev

Installation de FRP dans le serveur

On télécharge et décompresse la version spécifique à notre serveur linux (amd64) de FRP (Fast Reverse Proxy)

cd ~
wget https://github.com/fatedier/frp/releases/download/v0.49.0/frp_0.49.0_linux_amd64.tar.gz
tar -xvf frp_0.49.0_linux_amd64.tar.gz

On se rend dans le dossier decompressé, et on modifie le contenu du fichier frps.ini (« s » pour server)

cd frp_0.49.0_linux_amd64
vi frps.ini

par :

[common]
bind_port = 7000
vhost_http_port = 8080

On démarre ensuite frps en tâche de fond avec nohup

nohup ./frps -c ./frps.ini >/dev/null 2>&1 &

Installation de FRP dans Termux

On se connecte à nouveau en SSH dans termux.

On télécharge et décompresse la version spécifique à termux (arm) de FRP

wget https://github.com/fatedier/frp/releases/download/v0.49.0/frp_0.49.0_linux_arm.tar.gz
tar -xvf frp_0.49.0_linux_arm.tar.gz

On se rend dans le dossier decompressé, et on modifie le contenu du fichier frpc.ini (« c » pour client)

cd frp_0.49.0_linux_arm/
vi frpc.ini

par :

[common]
server_addr = 192.99.160.149
server_port = 7000

[web]
type = http
local_port = 8080
custom_domains = mrok.miary.dev

On démarre ensuite frpc en tâche de fond avec nohup

nohup ./frpc -c ./frpc.ini >/dev/null 2>&1 &

Reverse proxy avec apache2

Sur le serveur linux, on a apache2 qui est installé, comme serveur web, et non nginx. On va donc créer un fichier de configuration spécifique à Apache2 pour le nom de domaine mrok.miary.dev. Le serveur fonctionnera comme un reverse proxy, et va envoyer toutes les requêtes à http://localhost:8080/.

vi /etc/apache2/sites-available/mrok.miary.dev.conf

Avec le contenu suivant

<VirtualHost *:80>
        ServerName mrok.miary.dev
        RewriteEngine on
        RewriteCond %{SERVER_NAME} =mrok.miary.dev
        RewriteRule ^ https://%{SERVER_NAME}%{REQUEST_URI} [END,NE,R=permanent]
</VirtualHost>


<IfModule mod_ssl.c>
    <VirtualHost *:443>
        ServerName mrok.miary.dev
        
        ProxyPreserveHost On
        ProxyRequests off
        ProxyPass / http://localhost:8080/
        ProxyPassReverse / http://localhost:8080/

SSLCertificateFile /etc/letsencrypt/live/mrok.miary.dev/fullchain.pem
SSLCertificateKeyFile /etc/letsencrypt/live/mrok.miary.dev/privkey.pem
Include /etc/letsencrypt/options-ssl-apache.conf
    </VirtualHost>
</IfModule>

On active le site

a2ensite mrok.miary.dev.conf

et on recharge apache2

systemctl reload apache2

Cette fois-ci, quand on ouvre le navigateur, et qu’on va sur https://mrok.miary.dev/ on devrait avoir ceci

Et voilà 😉 Amusez-vous bien