lora application server
version tuned with small adjustements and updated documentation
There are two options how to run application. Develop and deploy mode.
Both modes are using same docker volume (same database is loaded).
.env.example à .envclient/.env.development.example au client/.env.development si vous souhaitez exécuter l'application en mode développementclient/.env.production.example au client/.env.production si vous souhaitez exécuter l'application en mode de production${REACT_APP_GOOGLE_API} Suivez ces étapes This will just run db and pgadmin containers. React and server instances are running separately, outside of containers.
${DB_HOST} de .env à: localhostdocker-compose -f docker-compose.dev.yml up -dnpm i && npm run server${REACT_APP_BASE_URL} variable dans le fichier client/.env.development en conséquence à ${SERVER_PORT} spécifié dans le fichier .envcd client && npm i && cd .. && npm run clientlocalhost:3000 This will run db, pgadmin, server and build react with disabled redux devtools.
${DB_HOST} de .env à postgres .docker-compose up -d .localhost:${SERVER_PORT} .Pour le bon fonctionnement de l'application, la base de données doit être remplie en premier. Nous utiliserons la ligne de commande pour y parvenir.
À partir du répertoire racine, accédez au répertoire où se trouvent les données exportées.
cd dummy Ensuite, copiez des données dans l'exécution du conteneur Postgres (pour le mode de développement, utilisez dev_postgres_container ).
docker cp dbexport.sql postgres_container:/
Ensuite, entrez le conteneur (pour le mode de développement, utilisez dev_postgres_container ).
docker exec -it postgres_container /bin/bash
Si vous souhaitez importer des données dans une base de données déjà peuplée, vous devez d'abord supprimer le tableau existant, puis en créer un nouveau. Dans la console de conteneur, supprimez la base de données existante. (sautez cette étape si vous n'avez pas encore créé de base de données)
dropdb -U ${DB_USER} ${DB_NAME}Connectez-vous au serveur Postgres en tant qu'utilisateur.
su - ${DB_USER}Créez ensuite une nouvelle base de données.
createdb ${DB_NAME}Sortez de la console du serveur Postgres.
exitRépondez à la base de données avec de nouvelles données.
psql -d ${DB_NAME} -U ${DB_USER} -f dbexport.sql Vous pouvez maintenant vous connecter à l'application. name et password par défaut sont: admin .
localhost:${DB_PORT}${DB_USER}${DB_PASSWORD}http://localhost:${PGADMIN_PORT}${PGADMIN_EMAIL}${PGADMIN_PASSWORD}postgres${DB_PORT}${DB_NAME}${DB_PASSWORD} Le fichier docker est situé au niveau racine du projet et il est utilisé uniquement pour le mode de déploiement.
# Dockerfile
FROM node:latest
WORKDIR /server
COPY . ./
RUN npm install
RUN npm install --prefix client
CMD npm run build Au début, le dernier nœud est téléchargé et le répertoire de travail /server est créé dans un conteneur nouvellement créé. Dans ce répertoire fonctionnel, le code source entier est copié, attendez-vous aux fichiers spécifiés dans client/.dockerignore . Ces fichiers sont omis. Ensuite, les dépendances de nœuds sont installées dans le répertoire de travail pour les instanies du serveur et du client. Enfin, la commande npm run build est appelée qui est située dans package.json . Cette commande construit d'abord l'application React, puis déclenchent le serveur. Lorsque le serveur est démarré de cette façon, la variable d'environnement NODE_ENV est définie sur production et la version construite de l'application React est utilisée.
Nous utilisons deux fichiers Docker-Compose. Le docker-compose.dev.yml pour le mode de développement et docker-compose.yml pour le mode de production, tous deux situés dans le répertoire racine. Chaque fichier composé charge les variables d'environnement spécifiées dans le fichier .env .
# docker-compose.dev.yml
version : " 3.5 "
# inspired by https://github.com/khezen/compose-postgres
services :
postgres :
container_name : postgres_container
image : postgres:11
environment :
POSTGRES_USER : ${DB_USER}
POSTGRES_PASSWORD : ${DB_PASSWORD}
PGDATA : /data/postgres
volumes :
- postgres:/data/postgres
ports :
- " ${DB_PORT}:5432 "
networks :
- postgres
restart : always
pgadmin :
container_name : pgadmin_container
image : dpage/pgadmin4
environment :
PGADMIN_DEFAULT_EMAIL : ${PGADMIN_EMAIL}
PGADMIN_DEFAULT_PASSWORD : ${PGADMIN_PASSWORD}
PGADMIN_CONFIG_SERVER_MODE : " False "
volumes :
- pgadmin:/root/.pgadmin
ports :
- " ${PGADMIN_PORT}:80 "
networks :
- postgres
restart : always
server :
container_name : server_container
build :
context : .
dockerfile : Dockerfile
depends_on :
- postgres
ports :
- " ${SERVER_PORT}:${SERVER_PORT} "
networks :
- postgres
restart : always
networks :
postgres :
driver : bridge
volumes :
postgres :
pgadmin : Cette configuration de composition crée 3 conteneurs, 1 réseau et 1 volume pour stocker des données persistantes. Chaque conteneur utilise le même réseau pour la communication avec d'autres conteneurs. Chaque conteneur, après échec, redémarre automatiquement. Container postgres_container crée un serveur postgresql, où les données persistantes sont stockées en volume. Il existe également un conteneur pgadmin_container , qui est SQL Client. Le dernier conteneur, nommé server_container , est l'endroit où notre application principale est en cours d'exécution. Au lieu de l'image, il utilise Build, défini dans Dockerfile, discuté dans la section précédente.
La configuration de composition pour le mode de développement est très similaire à un pour le mode de déploiement. La seule différence est qu'il n'y a pas server_container , car le serveur et le client sont des instances distinctes qui s'éloignent de Docker.
.env.example à .env et définir la valeur de ${DB_HOST} à postgres .client/.env.production.example au client/.env.production .${REACT_APP_GOOGLE_API} dans client/.env.production , suivez ces étapes. Le proxy inversé doit être défini pour transférer l'accès à Jenkins et au serveur d'applications. Les ports spécifiés dans ./env doivent correspondre à ceux de la configuration proxy inverse de Nginx.
Tout d'abord, accédez au répertoire de configuration des sites disponibles.
cd /etc/nginx/sites-available/ Créer un fichier config. Vous pouvez le nommer pendant que vous vous youxiez. La bonne pratique est de le nommer de la même manière que votre adresse DNS. Dans notre cas, c'est lora.fiit.stuba.sk .
touch lora.fiit.stuba.sk Copiez et collez le code suivant dans le fichier nouvellement créé. Modifier la configuration de proxy_pass pour chaque emplacement pour correspondre aux ports spécifiés dans .env . N'oubliez pas d'ajuster également server_name pour correspondre à votre DNS.
upstream jenkins {
keepalive 32; # keepalive connections
server 127.0.0.1:8080; # jenkins ip and port
}
# Required for Jenkins websocket agents
map $http_upgrade $connection_upgrade {
default upgrade;
'' close;
}
server {
server_name lora.fiit.stuba.sk www.lora.fiit.stuba.sk;
# this is the jenkins web root directory
# (mentioned in the /etc/default/jenkins file)
root /var/run/jenkins/war/;
access_log /var/log/nginx/jenkins/access.log;
error_log /var/log/nginx/jenkins/error.log;
# pass through headers from Jenkins that Nginx considers invalid
ignore_invalid_headers off;
location /jenkins/ {
autoindex on ;
sendfile off ;
proxy_pass http://jenkins/jenkins/;
proxy_redirect default ;
proxy_http_version 1.1 ;
# Required for Jenkins websocket agents
proxy_set_header Connection $connection_upgrade ;
proxy_set_header Upgrade $http_upgrade ;
proxy_set_header Host $host ;
proxy_set_header X-Real-IP $remote_addr ;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for ;
proxy_set_header X-Forwarded-Proto $scheme ;
proxy_max_temp_file_size 0 ;
#this is the maximum upload size
client_max_body_size 10m ;
client_body_buffer_size 128k ;
proxy_connect_timeout 90 ;
proxy_send_timeout 90 ;
proxy_read_timeout 90 ;
proxy_buffering off ;
proxy_request_buffering off; # Required for HTTP CLI commands
proxy_set_header Connection "" ; # Clear for keepalive
}
location / {
#Add serving gzipped files
gzip_static on ;
gzip on ;
gzip_proxied no-cache no-store private expired auth;
gzip_min_length 256 ;
gzip_types
text/plain
text/css
application/json
application/javascript
text/xml
application/xml
application/xml+rss text/javascript
application/atom+xml
application/geo+json
application/x-javascript
application/ld+json
application/manifest+json
application/rdf+xml
application/rss+xml
application/xhtml+xml
font/eot
font/otf
font/ttf
image/svg+xml;
proxy_pass http://127.0.0.1:5000/;
proxy_set_header Host $host ;
proxy_set_header X-Real-IP $remote_addr ;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for ;
proxy_set_header X-Forwarded-Proto $scheme ;
# enable WebSockets
proxy_http_version 1.1 ;
proxy_set_header Upgrade $http_upgrade ;
proxy_set_header Connection "upgrade" ;
}
listen 443 ssl; # managed by Certbot
# SSL Configuration
ssl_certificate /etc/letsencrypt/live/lora.fiit.stuba.sk/fullchain.pem; # managed by Certbot
ssl_certificate_key /etc/letsencrypt/live/lora.fiit.stuba.sk/privkey.pem; # managed by Certbot
include /etc/letsencrypt/options-ssl-nginx.conf; # managed by Certbot
ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; # managed by Certbot
}
# SSL redirect from HTTP to HTTPS
server {
if ( $host = lora.fiit.stuba.sk) {
return 301 https:// $host$request_uri ;
} # managed by Certbot
listen 80 ;
server_name lora.fiit.stuba.sk www.lora.fiit.stuba.sk;
return 404 ; # managed by Certbot
}Enregistrer le fichier et redémarrer le service Nginx
sudo systemctl restart nginx L'application Jenkins doit être accessible sur lora.fiit.stuba.sk/jenkins . Dans votre cas, ce serait votre nom DNS au lieu de lora.fiit.stuba.sk .
Lorsque vous souhaitez modifier la maison par défaut pour Jenkins, vous pouvez modifier la variable JENKINS_HOME . Le guide est fortement inspiré par ce tutoriel.
Créez un nouveau répertoire où que vous souhaitiez déplacer la maison Jenkins. Dans notre cas, c'est /data/jenkins .
mkdir /data/jenkinsChanger la propriété du répertoire nouvellement créé.
sudo chown jenkins:jenkins /data/jenkins Copiez le contenu de Old Jenkins Home Directory, /var/lib/jenkins/ , dans le nouveau répertoire domestique Jenkins, /data/jenkins/ , en utilisant la commande suivante.
sudo cp -prv /var/lib/jenkins /data/jenkins/Ensuite, modifiez la maison utilisateur de Jenkins.
sudo usermod -d /data/jenkins/ jenkins Mettez à jour le nouveau chemin du répertoire de la maison Jenkins dans /etc/default/jenkins . Vous pouvez utiliser n'importe quel éditeur de votre choix. Dans notre cas, nous utilisons VI.
sudo vi /etc/default/jenkinsFaites défiler jusqu'à l'emplacement de Jenkins Home et mettez à jour le nouveau chemin du répertoire domestique.
# defaults for Jenkins automation server
# pulled in from the init script; makes things easier.
NAME=jenkins
# arguments to pass to java
# Allow graphs etc. to work even when an X server is present
JAVA_ARGS= " -Djava.awt.headless=true "
# JAVA_ARGS="-Xmx256m"
# make jenkins listen on IPv4 address
# JAVA_ARGS="-Djava.net.preferIPv4Stack=true"
PIDFILE=/var/run/$NAME/$NAME.pid
# user and group to be invoked as (default to jenkins)
JENKINS_USER=$NAME
JENKINS_GROUP=$NAME
# location of the jenkins war file
JENKINS_WAR=/usr/share/$NAME/$NAME.war
# jenkins home location
JENKINS_HOME=/data/$NAME
# set this to false if you don't want Jenkins to run by itself
# in this set up, you are expected to provide a servlet container
# to host jenkins.
RUN_STANDALONE=trueDémarrez le service Jenkins en utilisant la commande suivante.
sudo service jenkins start
Visitez Jenkins de votre navigateur à lora.fiit.stuba.sk/jenkins .
Connectez-vous à l'application.
Naviguez pour Manage Jenkins situé dans le côté gauche de l'écran.
Cliquez sur Onglet Manage Credentials situées dans Security group .
Ensuite, cliquez sur le lien (global) situé dans le tableau.
Cliquez sur le bouton addCredentials sur le côté gauche de l'écran.
Choisissez l'option Secret file dans le menu déroulant Kind .
Télécharger le fichier .env rempli et le champ ID définir sur env .
Répétez l'étape 6, puis téléchargez le fichier client/.env.production rempli et définissez le champ ID sur envClient .
Créez un autre identifiant mais cette fois, choisissez SSH Username with private key à partir du menu déroulant. Définissez le champ ID sur lora-application-server-ssh . Pour obtenir des clés SSH pour votre référentiel (où se trouve le code source du serveur d'applications), suivez ces instructions.
Depuis le tableau de bord, cliquez sur le bouton New Item , situé à gauche de l'écran.
Entrez le nom souhaité, cliquez sur le bouton Pipeline et confirmez-le en cliquant sur le bouton OK
Au script de pipeline Coller le code suivant
node {
/*** 1 Pull new changes from git branch deploy ***/
stage ( 'Pull master branch' ) {
git credentialsId : 'lora-application-server-ssh' , url : '[email protected]:danielhros/lora-application-server.git'
}
/*** 2 Add secret enviroment variables stored securely in Jenkins ***/
stage ( 'Add enviroment variables' ) {
/* 2.1 Remove .env file if exists */
sh 'rm -f -- .env'
/* 2.2 Add .env file to server */
withCredentials ( [ file ( credentialsId : 'env' , variable : 'env' ) ] ) {
sh "cp $env ./"
}
/* 2.2 Add .env file to client */
withCredentials ( [ file ( credentialsId : 'envClient' , variable : 'envClient' ) ] ) {
sh 'cp $envClient client/.env.production'
}
}
/*** 3 Build docker image ***/
stage ( 'Build docker image' ) {
sh '(docker-compose build)'
}
/*** 4 Run docker image in production ***/
stage ( 'Run docker images' ) {
sh '(docker-compose up -d)'
}
/*** 5 Clean after build ***/
stage ( 'Clean workspace' ) {
sh 'docker system prune -f'
cleanWs ( )
}
}Enregistrez les modifications et exécutez votre premier pipeline
Félicitations! Après la création et le déploiement avec succès de l'application, votre application est accessible sur lora.fiit.stuba.sk .
