Netbeans Days

Vendredi dernier avait lieu la première rencontre autour de NetBeans à Paris. Netbeans est un IDE OpenSource écrit en Java/swing qui existe quasiment depuis aussi longtemps que JAVA.

Il est construit à partir d'un framework swing NetBeans Framwork qui permet des développements rapides d'application riche.

Je me suis occupé des vidéos en voici un résumé des interventions

Fonctionnalités et nouveautés incontournables de NetBeans IDE(VO)

Geertjan Wielenga de oracle nous présente netbeans, ces origines est sa philosophie. Il présente les fonctionnalités de l'IDE. - Utilisation des structures standard des projets sans modification (Maven, ant, Node, cordova…) - L'outil de complétion, de création de codes et de manipulation de code - De nombreux widget pour refacturer le code dont le “Turn to lamba expression” qui permet de convertir des syntaxes de boucle 1.7 en syntaxe 1.8, plus compatible Lambda et certains diront plus lisible. - L'intégration au navigateur web …. C'est une bonne entrée en matière pour la prise en main de cet IDE, qui à de très nombreux atout à vous donner

La communauté NetCat

Éric Barboni de l'Université de Toulouse nous présente la communauté NetCat, en charge de la validation de l'outil. Il s'agit de l'ensemble des travaux réalisé par la communauté pour vérifier la Qualité de l'IDE, la non-régression. Il y a des dizaines de bénévoles qui consacrent un parti de leurs temps personnel à la vérification de l'outil. Le cycle est de l'ordre de 3 mois, avec un mois de préparation, un mois de test et un mois de consolidation.

La communauté NetCat

Éric Barboni de l'Université de Toulouse nous présente la communauté NetCat, en charge de la validation de l'outil. Il s'agit de l'ensemble des travaux réalisé par la communauté pour vérifier la Qualité de l'IDE, la non-régression. Il y a une dizaine de bénévoles qui consacrent une partie de leurs temps personnel à la vérification de l'outil. Le cycle est de l'ordre de 3 mois, avec un mois de préparation, un mois de test et un mois de consolidation.

La communauté (suite)

Geertjan Wielenga présente différents types de soutien de NetBeans à ces utilisateurs et présente certains cas d'usage de communication.

De JavaEE à AngularJS

Nebrass Lamouchi de la société de conseil Davidson SI, nous présent un cas d'usage de développement, d'un service métier exposé en REST et consommé à partir d'angular JS.

La présentation présente de nombreux atouts de NetBeans, comme la complétion des annotations, l'intégration de différents types de code (Java/JavaBeans/JavaScript, etc…)

C'est sans doute une présentation à creuser un peu pour un développement classique de JEE via Netbeans.

Faites nager des robots avec NetBeans Plateform

Guillaume Genty présent RobotSwim. Il présent plus particulièrement l'interface développée en NetBeans Plateforme et comment l'IDE facilite le développement JNI (Java Native Interface). Un joli projet IOT (internet of things) avec un cas d'usage de l'apport de java pour l'intégration de composants dans des environnements complexes.

Développement rapide JavaEE avec WildFly

Emmanuel Hugonnet de Red Hat nous présente ces travaux d'intégration de WildFly au sein de l'IDE NetBeans. Intégration qui apport une utilisation seamless du serveur d'application au sein des projets ainsi qu'un grand nombre d'aides comme l'affichage des Ressources JAX-RS. Un très beau travail qui va faciliter nos travaux de développeur.

Plateforme NetBeans : UNESCO J-ISIS

Jean-Claude Dauphin présente un outil de consultation des bases de données documentaire utilisée par l'UNESCO developper à l'aide de NetBeans Framework.

Plateforme NetBeans : EasyTopo

Fabrice Irie nous présente EasyTopo, un outil de consultation d'information géographique SIG (information géographique).

Plateforme NetBeans : Audiveris

Herve Bitteur nous présent son projet Audiveris: outils de ORM reconnaissance de partition de musique, pour pouvoir numérisé des partitions de musique pour les transformée dans un format utilisable par les programmes informatiques.

Développement modulaire avec la plateforme NetBeans

Présentation par Geertjan Wielenga de NetBeans Framework pour le développement rapide et modulaire d'application riche swing. Un vrai raccourcit pour développer des applications client lourdes.

Introduction

Ansible est un outil python scripting de déploiement. L'idée est de définir un script d'installation. Le script est un fichier en YAML. Il me semble que sa spécificité principale est de ne pas nécessiter d'agent et d'être exécuter principalement via SSH, d'avoir un faible impact mémoire.

Il y a (IMHO) 3 concepts majeurs à prendre en compte : - Le playbook - Les modules - Les rôles

le playbook

C'est le script d'installation à proprement parler. Il contient une suite de propriétés qui seront utilisées pour exécuter l'installation de la machine distante.

les modules

Les modules sont les “commandes” qu'il est possible d'exécuter directement par ansible. Elles sont développées en python et encapsulent des actions de plus bas niveau (yum install, mkdir, service start etc…)

Les rôles

Les rôles sont des playbooks qui définissent un ensemble ou sous ensemble d'opérations d'installation. Au sein de votre SI (système d'information) vous avez des serveurs de base de données, des serveurs d'application, des reverse-proxy, etc…, ces rôles sont donc des templates (modèle) d'installation.

NB : _L'internet, Git, c'est le partage, la capitalisation, le croudsourcing c'est pour cela qu'il existe Galaxy Ansible qui permets d'avoir une vaste bibliothèque de rôles développer par des tiers.

En pratique

Un playbook

Un playbook ressemble à cela :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

‘‘‘
- hosts: webservers
  vars:
    http_port: 80
    max_clients: 200
  remote_user: root
  tasks:
  - name: ensure apache is at the latest version
    yum: pkg=httpd state=latest
  - name: write the apache config file
    template: src=/srv/httpd.j2 dest=/etc/httpd.conf
    notify:
    - restart apache
  - name: ensure apache is running (and enable it at boot)
    service: name=httpd state=started enabled=yes
  handlers:
    - name: restart apache
      service: name=httpd state=restarted
‘‘‘

ou bien

1
2
3
4
5
6
7
8

‘‘‘
- hosts: webservers
  vars:
    http_port: 80
    max_clients: 200
 rôles:
   - {role: webservers-template}
‘‘‘

Un role

1
2
3
4
5
6
7
8
9
10
11
12
13

‘‘‘
ls -l ansible-xwiki-ctrl/

defaults/main.yml
files/main.yml
handlers/main.yml
meta/main.yml
tasks/main.yml
templates/
vars/main.yml
README.md

‘‘‘

Installation/configuration

Je passe ce point, il y a plein d'information pour cela, je n’ai pas eu de soucis avec pep (je dois commencer à m'y faire) ;-)

En pratique

Sur cette base, j'ai essayé de créer des rôles pour XWiki à titre d'exercices. J'ai donc divisé ma stack (pile applicative) suivant ces différents rôles : - jdk - mysql - tomcat - war - ctrl

Vous trouverez les rôles sur git-hub et les exercices de variabilisation ici

En pratique, je peux donc installer sur un serveur “debian” le jdk 7 ou 8 (openjdk ou oracle), mysql que je veux (debian ou mysql.org), la version d'Xwiki que je souhaite. En modifiant les vars de mon script ou la target de mon playbook.

Conclusion

Complexité et modularité

Mon constat est que comme souvent le niveau de variablilisation, de ce qu'il faut rendre paramétrable, est toujours un curseur à revoir en fonction du contexte et de ce que l'on souhaite mettre en oeuvre.

Strategie d'upload

Ayant travaillé depuis ma machine locale, j'ai downloadé plusieurs fois au cours de l'exercice les paquets de plusieurs Mo. Il y a des stratégies, pour les copier depuis sa machine et/ou répliquer en parallèle. C'est un point qu'il est nécessaire de creuser en fonction de son environnement.

Immuabilité et test

Personnellement, j'ai utilisé Virtualbox pour faire des snapshot et valider mes playbook, j'ai regardé pour le fun docker+jenkins, un retour dessus peut être plus tard.

Strategie de template de VM

Avec ansible, je produis un script d'installation qui me permet notamment d'avoir un seul script, quels que soient mes environnements (en ayant variabilisé les OS), mais cela peu prendre un certain temps, il peut y avoir des gains à partir d'image de VM provisionner. J'ai entendu parler d'utiliser ansible sur docker pour les environnements de dev et d'appliquer ces derniers sur des VM pour la prod. À creuser…

Les deux trois trucs pour débugger

Pour connaître les facts

1

ansible -m setup nodexwiki | less

Pour valider la bonne interprétation du playbooks

1

ansible-playbook ansible-xwiki-example/example.yml --check

L'accès à distance

Dans mon blog précédent, on s'est rappelé combien la ligne de commande était un outil pratique et que cela permettait d'automatiser des opérations. L'informatique c'est l'automatisation par nature. La ligne de commande permet donc d'enchaîner mes taches. C'est une abstraction en cela que votre ligne de commande peut être exécutée à distance. Historiquement via telnet, mais le flux réseau en telnet n'est pas chiffrer, on préfère donc utiliser SSH (Secure Shell).

SSH

Clés publiques

Pour que l'échange soit privé, il y a un mécanisme de chiffrement asymétrique, avec un CLe priver et une clé publique. Lorsque vous vous connectez à un serveur ayant un service SSH, vous faites un échange de clés. La clé du serveur sera associée à son IP dans ~/.ssh/known_hosts.

1
2
3
4
5

# ssh jvaljeanuser@example.com
Host key not found from the list of known hosts.
Are you sure you want to continue connecting (yes/no)? yes
Host 'example.com' added to the list of known hosts.
user@example.com's password: *******

Par défaut, un serveur ssh autorise l'authentification par mot de passe. C'est pratique, mais finalement pas tellement sécurisé. Pizza73 et 01022008 sont des mots de passe faciles à bruteforcer. Il est donc préférable de préférer une authentification par clés.

configuration OpenSSH

Pour mieux sécuriser son serveur, on va :

• interdire l'utilisateur root
• interdire l'authentification par mots de passe
• définir l'emplacement des clés autorisé
• ajoute la clés de l'utilisateur jvaljean (on verra comment la créer plus loin)

NB : Cette commande est proposée en root, mais elle passe avec sudo.

ATTENTION après cela on ne peut plus ce connecter avec l'utilisateur root

1
2
3
4
5
6
7
8

TIMESLOT=`date +%Y-%m-%d-%H-%M-%S` && cp /etc/ssh/sshd_config /etc/ssh/sshd_config.$TIMESLOT && \
sed -i -e "s/PermitRootLogin yes/PermitRootLogin no/g" /etc/ssh/sshd_config && \
sed -i -e "s/#PasswordAuthentication yes/PasswordAuthentication no/g" /etc/ssh/sshd_config && \ 
/etc/init.d/sshd restart && \
mkdir /home/jvaljean/.ssh/ &&
echo "ssh-rsa X2xEB3NzaC1yc2EX2xEDAQABAAACAQCb3AG5VnbDxV3iEdLd+gqVQsOWlx7rg9K4O7i8S8SK5j1/tMq8LWTpzQToEUvOU1Psgmk/rMG2y1qvk1J3xN5s+YIeisXznMgdAF7qotGFbZy1Z6qd/hDqnmu0WbxBBvQOwe4CeyQ75heGx5HXiD2Sshv5sLemNcST4UwNx/TWBpcH0y5oGH1j+3opexQM4enOkJCFAvkBiwJ/oS4v55Qdd59dXHFr9h9TP5MYSa6H/x4BJjumAr9Epd1zTaiuR475cIjmSfB5cHDTqFv82FKCLl2IBnNc2rw5ISXASqcOblbRayEq73kEvd8zuyeA9cAT3Eq9Y3j15mAsjjwQEHx31lt6iLFIZaaCmTYtN3g7F6hv2VnVAJGmwc6cD7Ow9HGo4pLSjxqUwYdVLKSz/5ftT/bltK0S6DicNrGhCRBFUIL7EKO5pqrUa5bKQfHyiKCv8WvjK97KUpqKlCDE+Q7mpJZ3VnFz2WYVczS0sP39g9L976QJ80EfjllwD3cvfduhNhCFoVd3cLVWyxIUW7b/gpfulLgKhT4LabQdWx5445LHMiUSnGql3gH/P/bn5d/5YWvDZTo3YICE0fSEq--4qhQbXRdIPZQxf+yTbIB91ZuXtJrPRLYUWdfXCYsl4ktrqAlfycopOD5vjeNtvWyUhHg3zFVIb+Hzb7e3ZIzYtQ== jvaljean@example.com" >> /home/jvaljean/.ssh/authorized_keys &&
chown -Rv jvaljean:jvaljean /home/jvaljean/.ssh/ && \
chmod u+rw,og-rwx /home/jvaljean/.ssh/authorized_keys

Maintenant, l'utilisateur root ne peux plus ce connecter, l'utilisateur jvaljean peut se connecter uniquement avec sa clé publique “ssh-rsa X2x…”

création de la clé

Pour créer sa cles il faut choisir :

• sa taille : 4 096 (d'après l'ANSII donne une durée de vie acceptable ici : http://www.ssi.gouv.fr/uploads/2015/01/RGS_v-2-0_B1.pdf)
• l'algorithme : RSA (par défaut)
• l'emplacement de la clé (Et oui, on peut et devrais avoir plusieurs clés, on y reviendra plus loin, sinon c'est id_rsa)
• un mot de passe pour utiliser la clé (évitons pizza82)

1

ssh-keygen -t rsa -b 4096 -C "jvaljean@example.com"

ou

1

ssh-keygen -t rsa -b 4096 -C "jvaljean@example.com" -f ~/.ssh/id_mongroupedeserver_algo

Après on peut se connecter au serveur ayant notre clé avec la commande ssh Rappel :

1

ssh example.com

ou

1

ssh -p 22 -i ~/.ssh/id_mongroupedeserver_algo jvaljean@example.com

le port-mapping

Une fonction très pratique de SSH est le port mapping il est possible de mapper un port de votre client local à celui du serveur distant. Cela permet de vous connecter à distance sur vos serveurs comme si vous étiez dans votre réseau. on peut par exemple mapper le port 8080 d'un Tomcat sur son 8888 local comme ceci

1

ssh -p 22 -i ~/.ssh/id_mongroupedeserver_algo jvaljean@example.com -L 127.0.0.1:8888:example.com:8080

on pourra par la suite accéder depuis son client web local sur http://127.0.0.1:8888 comme si nous étions sur le réseau local de la machine

~/.ssh/config

Nous l'avons vu précédemment, la clé d'authenfication est précieuse, mais il est parfois nécessaire de la copier sur d'autre machine, elle peut être corrompu ou obsolète. Enfin, certains groupes de serveur peuvent nécessiter des sécurités différentes. Pour cela, il est conseillé d'avoir plusieurs cles. Pour éviter de taper des commandes trop longues, il est possible de définir les commandes “par défaut, par host dans ”~/.ssh/config" sous la forme :

• Host : les serveurs utilisant cette configuration (liste séparée d'un espace)

• Hostname : le nom du serveur qui appelle celui annoncé par le client
  User : le nom de l'utilisateur à utiliser
    IdentityFile ~/.ssh/id_github_mb35_rsa
  

1
2
3
4
5

Host example.com
        Hostname jvaljean@example.com
        User jvaljean@example.com
        LocalForward 8888 127.0.0.1:8080
        IdentityFile ~/.ssh/id_mongroupedeserver_algo 

Conclusion

SSH est l'outil de base du sysadmin et du très tendance DevOps. IMHO (à mon humble avis) “~/.ssh/config” n'est pas suffissement connu.

Les terminaux

Un terminal est un accès à un ordinateur central. Sous Linux, on parle de terminal pour l'invite de commande. L'avantage de l'invite de commande à mon avis est que c'est :

• simple
• relativement standard (malgré des querelles d'interpréteur que je ne développerais pas maintenant)
• faible coût et faible coût réseau
• facilement automatisable

C'est pourquoi c'est sans doute l'outil de base qu'il faut apprendre à maîtriser en priorité. IMHO (à mon humble avis), c'est l'essence de l'informatique, le reste devrait découler naturellement dans l'optique basic de ce simplifier la vie.

l'enchaînement des commandes

Mes commandes de prédilections sont :

• cat et zcat pour afficher les contenus d'un fichier
• less et zless pour afficher les contenus d'un fichier de façon interactive
• grep pour trouver un morceau de texte dans un long fichier
• tail pour afficher la fin d'un fichier texte
• tail -f pour afficher la fin d'un fichier texte et
• mnon qui affiche l'activité de mon serveur
• sed pour remplacer un morceau de TEXT par un autre
• sudo pour passer des commandes avec des droits particuliers (souvent, root)

Je pense qu'il faut comprendre l'idée des “pipe” (tuyaux) en priorité. L'idée est que votre travail est un flux, comme un cours d'eau ou un courant électrique et que vous avez la possibilité de brancher les entrées et les sorties de vos commandes les unes aux autres.

Les branchements sont :

• “;” juste pour enchaîner les commandes
• “&&” pour enchaîner les commandes uniquement tant que les commandes s'exécutent sans problème
• “|” prendre en entrée la sortie d'une autre commande
• “<” donne en entrée la sortie d'une autre commande
• “>” écrire et remplacer le contenu de la commande dans un fichier
• “>>” écrire ajouter le contenu de la commande dans un fichier

En pratique, pour mettre à jour un fichier de configuration par exemple après avoir créé commander un nouveau serveur, vous voulez :

1
2
3
4
5

- créer l'utilisateur jvaljean 
 - créer un groupe admin
 - mettre jvaljean dans ce groupe
 - donner les droits de sudo aux membres de ce groupe 
 - interdire l'accès à votre machine à l'utilisateur root depuis SSH

Vous pouvez taper les commandes suivantes :

1
2
3
4
5
6

adduser jvaljean
groupadd admin
adduser jvaljean admin
nano /etc/sudoers (et ajouter "%admin    ALL=(ALL) ALL" à la fin du fichier)
nano /etc/ssh/sshd_config (et remplacer "PermitRootLogin yes" par "PermitRootLogin no")
relancer le service /etc/init.d/ssh restart

ou bien faire :

1

adduser jvaljean && groupadd admin && adduser jvaljean admin && echo "%admin    ALL=(ALL) ALL" >> /etc/sudoers && sudo sed -i -e 's/PermitRootLogin yes/PermitRootLogin no/g' /etc/ssh/sshd_config && sleep 2 && sudo /etc/init.d/ssh restart

Pour connaître les IP qui se sont connectés à votre serveur le “30 août entre 6 et 7 vous pouvez :

1
2
3

récupère votre fichier de log (scp ou ftp)
l'importer sur Excel
utiliser les filtres pour obtenir l'information

ou faire :

1
2

zcat /var/log/apache2/xwiki-access.log | grep "30/Aug/2015:06" | \
awk '{split($0,a," "); print a[1]}' | sort -nu

ou pour connaître la navigation de 192.168.1.10 le 30 Août 2015

1
2

zcat /var/log/apache2/xwiki-access.log.6.gz | grep "30/Aug/2015" | \
grep "192.168.1.10" | awk '{split($0,a," "); print a[4] a[6] a[7]}'

Et puis pour s'envoyer par mail le nombre d'IP connecter en une journée en une commande

1
2
3
4

TIMESLOT=`date +%d/%b/%Y` && \
NIP=$(cat /var/log/apache2/xwiki-access.log | grep "$TIMESLOT" | \
awk '{split($0,a," "); print a[1]}' | sort -nu | wc -l) \
&& echo "$NIP on $TIMESLOT" | mail -s "$NIP on $TIMESLOT" jvaljean@gmail.org

Conclusion

Probablement rien de nouveau sous le soleil je pense, mais je me suis dit qu'il était préférable d'avoir parlé de ces bases, avant de passer à la suite.