NoteKfet 2020

Installation sur un serveur

On supposera pour la suite que vous utilisez Debian/Ubuntu sur un serveur tout nu ou bien configuré.

1. Paquets nécessaires

    $ sudo apt install nginx python3 python3-pip python3-dev uwsgi
    $ sudo apt install uwsgi-plugin-python3 python3-venv git acl
   

   La génération des factures de l'application trésorerie nécessite une installation de LaTeX suffisante :

    $ sudo apt install texlive-latex-extra texlive-fonts-extra texlive-lang-french
   

2. Clonage du dépot

   on se met au bon endroit :

    $ cd /var/www/
    $ mkdir note_kfet
    $ sudo chown www-data:www-data note_kfet
    $ sudo usermod -a -G www-data $USER
    $ sudo chmod g+ws note_kfet
    $ sudo setfacl -d -m "g::rwx" note_kfet
    $ cd note_kfet
    $ git clone git@gitlab.crans.org:bde/nk20.git .
   

3. Environment Virtuel

   À la racine du projet:

    $ python3 -m venv env
    $ source env/bin/activate
    (env)$ pip3 install -r requirements/base.txt
    (env)$ pip3 install -r requirements/prod.txt # uniquement en prod, nécessite un base postgres
    (env)$ deactivate
   

4. uwsgi et Nginx

   Un exemple de conf est disponible :

    $ cp nginx_note.conf_example nginx_note.conf
   

   Modifier le fichier pour être en accord avec le reste de votre config

   On utilise uwsgi et Nginx pour gérer le coté serveur :

   $ sudo ln -sf /var/www/note_kfet/nginx_note.conf /etc/nginx/sites-enabled/
   

   Si l'on a un emperor (plusieurs instance uwsgi):

    $ sudo ln -sf /var/www/note_kfet/uwsgi_note.ini /etc/uwsgi/sites/
   

   Sinon:

    $ sudo ln -sf /var/www/note_kfet/uwsgi_note.ini /etc/uwsgi/apps-enabled/
   

   Le touch-reload est activé par défault, pour redémarrer la note il suffit donc de faire touch uwsgi_note.ini.

5. Base de données

   En prod on utilise postgresql.

    $ sudo apt-get install postgresql postgresql-contrib libpq-dev
    (env)$ pip3 install psycopg2
   

   La config de la base de donnée se fait comme suit:

   a. On se connecte au shell de psql

    $ sudo su - postgres
    $ psql
   

   b. On sécurise l'utilisateur postgres

    postgres=# \password
    Enter new password:
   

   Conservez ce mot de passe de la meme manière que tous les autres.

   c. On créer la basse de donnée, et l'utilisateur associé

    postgres=# CREATE USER note WITH PASSWORD 'un_mot_de_passe_sur';
    CREATE ROLE
    postgres=# CREATE DATABASE note_db OWNER note;
    CREATE DATABASE
   

   Si tout va bien :

    postgres=#\list
    List of databases
       Name    |  Owner   | Encoding |   Collate   |    Ctype    |   Access privileges   
    -----------+----------+----------+-------------+-------------+-----------------------
     note_db   | note     | UTF8     | fr_FR.UTF-8 | fr_FR.UTF-8 | 
     postgres  | postgres | UTF8     | fr_FR.UTF-8 | fr_FR.UTF-8 | 
     template0 | postgres | UTF8     | fr_FR.UTF-8 | fr_FR.UTF-8 | =c/postgres+postgres=CTc/postgres
     template1 | postgres | UTF8     | fr_FR.UTF-8 | fr_FR.UTF-8 | =c/postgres  +postgres=CTc/postgres
    (4 rows)
   

6. Variable d'environnement et Migrations

   On copie le fichier .env_example vers le fichier .env à la racine du projet et on renseigne des secrets et des paramètres :

    DJANGO_APP_STAGE=dev # ou "prod" 
    DJANGO_DEV_STORE_METHOD=sqllite # ou "postgres"
    DJANGO_DB_HOST=localhost
    DJANGO_DB_NAME=note_db
    DJANGO_DB_USER=note
    DJANGO_DB_PASSWORD=CHANGE_ME
    DJANGO_DB_PORT=
    DJANGO_SECRET_KEY=CHANGE_ME
    DJANGO_SETTINGS_MODULE="note_kfet.settings
    DOMAIN=localhost # note.example.com
    CONTACT_EMAIL=tresorerie.bde@localhost
    NOTE_URL=localhost # serveur cas note.example.com si auto-hébergé.
    NOTE_MAIL=notekfet@localhost  # Adresse expéditrice des mails
    WEBMASTER_MAIL=notekfet@localhost  # Adresse sur laquelle contacter les webmasters de la note
   

   Ensuite on (re)bascule dans l'environement virtuel et on lance les migrations

    $ source /env/bin/activate
    (env)$ ./manage.py check # pas de bêtise qui traine
    (env)$ ./manage.py makemigrations
    (env)$ ./manage.py migrate
   

7. Enjoy

Installer avec Docker

Il est possible de travailler sur une instance Docker.

1. Cloner le dépôt là où vous voulez :

    $ git clone git@gitlab.crans.org:bde/nk20.git
   

2. Copiez le fichier .env_example à la racine du projet vers le fichier .env, et mettez à jour vos variables d'environnement

3. Dans le fichier docker_compose.yml, qu'on suppose déjà configuré, ajouter les lignes suivantes, en les adaptant à la configuration voulue :

    nk20:
      build: /chemin/vers/nk20
      volumes:
        - /chemin/vers/nk20:/code/
      env_file: /chemin/vers/nk20/.env
      restart: always
      labels:
        - traefik.domain=ndd.example.com
        - traefik.frontend.rule=Host:ndd.example.com
        - traefik.port=8000
   

4. Enjoy :

    $ docker-compose up -d nk20
   

Installer un serveur de développement

Avec ./manage.py runserver il est très rapide de mettre en place un serveur de développement par exemple sur son ordinateur.

1. Cloner le dépôt là où vous voulez :

    $ git clone git@gitlab.crans.org:bde/nk20.git && cd nk20
   

2. Créer un environnement Python isolé pour ne pas interférer avec les versions de paquets systèmes :

    $ python3 -m venv venv
    $ source venv/bin/activate
    (env)$ pip install -r requirements/base.txt
   

3. Copier le fichier .env_example vers .env à la racine du projet et mettre à jour ce qu'il faut

4. Migrations et chargement des données initiales :

    (env)$ ./manage.py makemigrations
    (env)$ ./manage.py migrate
    (env)$ ./manage.py loaddata initial
   

5. Créer un super-utilisateur :

    (env)$ ./manage.py createsuperuser
   

6. Enjoy :

    (env)$ ./manage.py runserver 0.0.0.0:8000
   

En mettant 0.0.0.0:8000 après runserver, vous rendez votre instance Django accessible depuis l'ensemble de votre réseau, pratique pour tester le rendu de la note sur un téléphone !

Cahier des Charges

Il est disponible ici.

Documentation

La documentation est générée par django et son module admindocs. Commentez votre code !