Go to file
Pierre-antoine Comby c5ebd0297c Make disctinction between club/user/special 2020-02-22 16:33:35 +01:00
apps add description field to transactionTemplates 2020-02-22 16:33:23 +01:00
locale/fr/LC_MESSAGES Move locales to project root 2019-08-14 15:15:02 +02:00
note_kfet Merge branch 'master' of gitlab.crans.org:bde/nk20 2020-02-03 13:58:29 +01:00
static Merge branch 'master' into 'app_member' 2019-08-15 19:53:40 +00:00
templates Merge branch 'master' of gitlab.crans.org:bde/nk20 2020-02-03 19:30:15 +01:00
.coveragerc Fix CI 2019-08-14 15:31:46 +02:00
.gitignore use a example config files 2020-01-31 15:43:21 +01:00
.gitlab-ci.yml Regroup everything here 2019-07-08 12:55:48 +02:00
.pylintrc Regroup everything here 2019-07-08 12:55:48 +02:00
COPYING Add COPYING 2019-07-08 07:58:44 +02:00
Dockerfile Docker 2020-02-03 11:50:42 +01:00
LICENSE Added LICENSE file 2019-09-18 14:46:10 +02:00
README.md Docker 2020-02-03 11:50:42 +01:00
entrypoint.sh Docker 2020-02-03 11:50:42 +01:00
manage.py and so it begins 2019-07-07 20:49:02 +00:00
map_db.json Make disctinction between club/user/special 2020-02-22 16:33:35 +01:00
nginx_note.conf_example use a example config files 2020-01-31 15:43:21 +01:00
requirements.txt add Django Guardian 2020-01-21 22:09:20 +01:00
tox.ini Make continuous integration integrate well 2019-08-14 15:19:25 +02:00
uwsgi_note.ini split settings config between development and production 2020-01-27 20:49:02 +00:00
uwsgi_params and so it begins 2019-07-07 20:49:02 +00:00

README.md

NoteKfet 2020

License: GPL v3 pipeline status coverage report

Installation sur un serveur

On supposera pour la suite que vous utiliser 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-virtualenv git
    
  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:

     $ virtualenv env
     $ source /env/bin/activate
     (env)$ pip3 install -r requirements.txt
     (env)$ deactivate
    
  4. uwsgi et Nginx

    Un exemple de conf est disponible :

     $ cp nginx_note.conf_example nginx_note.conf
    

*** Modifier le fichier pour etre en accord avec le reste de votre config ***

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

    $ 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`.
  1. 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)
    

    Dans un fichier .env à la racine du projet on renseigne des secrets:

     DJANGO_APP_STAGE='prod'
     DJANGO_DB_PASSWORD='le_mot_de_passe_de_la_bdd'
     DJANGO_SECRET_KEY='une_secret_key_longue_et_compliquee'
    

    ALLOWED_HOSTS='le_ndd_de_votre_instance'

  2. Variable d'environnement et Migrations

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
  1. 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. 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/
       restart: always
       labels:
         - traefik.domain=ndd.exemple.com
         - traefik.frontend.rule=Host:ndd.exemple.com
         - traefik.port=8000
    
  3. Enjoy :

     $ docker-compose up -d nk20
    

Installer en local

Il est tout-à-fait possible de travailler en local, vive ./manage.py runserver !

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

     $ git clone git@gitlab.crans.org:bde/nk20.git
    
  2. Initialiser l'environnement Virtuel

     $ cd nk20
     $ virtualenv env
     $ source /env/bin/activate
     (env)$ pip install -r requirements.txt
    
  3. Migrations:

     (env)$ ./manage.py makemigrations
     (env)$ ./manage.py migrate
    
  4. Enjoy:

     (env)$ ./manage.py runserver
    

Minimal Setup

  1. Créer un superuser :

     (env)$ ./manage.py createsuperuser
    

Avec ce dernier vous pouvez vous connecter à l'interface admin de Django, avoir accès à la doc auto-générée du projet, jouer avec des models, etc ...

Cahier des Charges

Il est disponible ici.

Documentation

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