Cet article a pour but de détailler mon cheminement quant à mon apprentissage des technologies en lien avec le DevOps. Je partagerais donc avec vous les différentes étapes qui m'amènent à me former sur le sujet. Cet article servira de squelette et vous redirigera vers les différents articles abordant les technologies utilisé au cours de ce voyage vers la maîtrise de la philosophie DevOps.

Qu'est-ce que le DevOps?

Le DevOps est avant tout un mouvement, une philosophie en ingénierie informatique qui unifie le développement logiciel (dev) avec l'administration système et réseaux (ops).

Il est aujourd'hui, de par sa nature compliquée de définir avec exactitude ce que représente le DevOps tant celui-ci se transforme à mesure que de nouvelles technologies s'offrent à nous.

Cependant, si nous devions définir le DevOps dans sa vision la plus globale, celui-ci tendrait vers la promotion de l'automatisation et du monitoring de toutes les étapes de la création d'un logiciel. En l'occurrence, nous pourrions découper ces étapes en 5.

Chaque étape pourrait être divisée en sous-catégories et forme dans sa globalité, la chaîne du CI/CD pour Continuous Intégration/ Continuous Deployment (intégration et Déploiement Continue) ou plus communément appeler un Pipeline.

Si l'on devait résumer en d'autres mots ce qu'est le DevOps et son pipeline nous pourrions dire de par l'automatisation et la standardisation qu'il apporte, qu'il s'agit de l'entrée dans l'aire de l'industrialisation de l'IT, une aire ou la création artisanal d'une infrastructure s'effectue de manière industrielle, comme le furent les industries Ford à l'époque.

Pour qui?

Le DevOps s'adresse aussi bien aux développeurs soucieux d'en comprendre plus sur la chaîne de développement d'une application en adoptant une vision plus globale du SI que des administrateurs féru d'automatisation et de nouvelles technologies.

Les méthodes

Scrum

Scrum est un méthode agile destiné à contrôler les projets informatiques, facilitant la communication et les virages en temps opportun. Aujourd'hui, c'est une méthode privilégié en entreprise afin d'adopter l'approche dite "agile". Forte de son succès dans le monde de l'informatique, elle s'impose aujourd'hui comme une nouvelle organisation d'entreprise en « mode projet ».

Agile

La méthode agile est quant à elle basé sur le manifest agile qui prone quatre valeurs fondamentales : l’individu et interactions plutôt que processus. Les fonctionnalités opérationnelles plutôt que documentation exhaustive. La Collaboration avec le client plutôt que la contractualisation des relations. L’Acceptation du changement plutôt que la conformité aux plans.

Boite à outils

Un administrateur système DevOps n'est pas nécessairement obligé de connaitre chaques technologies sur le bout des doigts, il doit avant tout être capable de piocher dans une boite à outil et connaitre à minima un outil pour travailler sur chaques étapes du pipeline devops. En l'occurence, nous pourrions définir qu'un DevOps à besoins de maitriser sommairement des outils comme:

• un orchestrateur
• un ordonnanceur de tâches
• des outils de gestion de dépôts
• des outils de test unitaires
• des outils de monitoring
• avoir des connaissances en virtualisation (conteneurs, cloud, hyperviseur...)
• posséder des notions de base de données

Dans notre cas, si nous reprenons notre shéma de pipeline, voici les outils sur lesquelles nous allons nous concentrer durant ce tutoriel.

(Des outils se rajouterons à ce shéma au fur à mesure du temps)

Git flow

Il est important de comprendre la notion de git flow car celle-ci va définir les différents serveurs qui vont régir notre pipeline devops, notamment via un serveur de dev, de test, et de production.

Je vous invite à vous intéresser à git, notamment au travers du sheet cheat git en lien ci-dessous qui ne rentre pas dans les details de comment fonctionne git mais vous présente sommairement les différentes commandes et leur utilitée.

Cheat sheet - Git

W = working zone;S = staging zone;C = commit zone;B(*) = Branche *;H(*) = Header *; Initialisation Configuration $ git config --global user.email “email@domain.com” $ git config --global user.name “Denis Brogniart” Working zone Demarrer un dépot GIT #W $ git init Cloner un dépot…

Noob to RootBertrand Janvoie

Infrastructure

Notre intrastructure sera composé de 6 serveurs:

• Serveur jenkins : jenkins / docker / docker-compose / ansible
• Serveur gitlab
• Serveur BDD : postgresql
• Serveur dev : debian 11
• Serveur stage : debian 11
• Serveur prod : debian 11

Installation de l'infrastructure avec Vagrant

Vagrant est un logiciel libre et open-source permmant la création et la configuration d'envrionnements de développement virtuels. En l'occurence, celui-ci nous servira à generer les différentes VM (sur VirtualBox) afin de mettre en place l'infrastructure qui recevra notre pipeline.

Installation de virtualbox
sudo apt install virtualbox

Installation de vagrant

wget -O- https://apt.releases.hashicorp.com/gpg | gpg --dearmor | sudo tee /usr/share/keyrings/hashicorp-archive-keyring.gpg

echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list

sudo apt update && sudo apt install vagrant

Commandes à retenir:

• vagrant up : télécharge et lance l'image
• vagrant up : telecharge et lance l'image définit dans le vagrant file.
• vagrant snapshot push : fait un snapshot de la VM
• vagrant snapshot list : listes les snapshots
• vagrant snapshot pop : charge le snapshot
• vagrant halt : arrête la ou les machines
• vagrant destroy : détruit la ou les machines
• vagrant status : listes les machines
• cat Vagrantfile | grep -ri "ip" : liste les ips des machines
• Documentation : https://www.vagrantup.com/docs

Installation des VMs

1. Serveur Jenkins, Dev, Stage, Prod:
   (Git) Configuration Vagrant - Serveur Jenkins, Dev, Stage, Prod
2. Serveur DDB

W = working zone;
S = staging zone;
C = commit zone;
B(*) = Branche *;
H(*) = Header *;

Initialisation

Configuration

$ git config --global user.email "email@domain.com"
$ git config --global user.name "Denis Brogniart"

Working zone

Demarrer un dépot GIT #W

$ git init

Cloner un dépot existant #C➜W

$ git clone [url]

Indexer des fichiers existants #W➜S

$ git add [file]
$ git add

Staging zone

Vérifier l'état du fichier #S

$ git status

Copier un fichier du dépot vers la zone de staging #C➜S

$ git reset

Visualiser les modifications non-indexés #S

$ git diff

Commit

Validation des modifications #S➜C

$ git commit -m "message de validation"

Historique des modifications #log(C)

$ git log

commit 67d6a5214ad4b259407ec7836b9d729f9f7de731
Author: Bertrand
Date:   Fri Jul 5 10:45:50 2013 +0200

   create reminders admin module

commit 05ca141b9e982c7d04100c37300da4209305b900
Author: Bertrand
Date:   Fri Jul 5 10:29:56 2013 +0200

   Create user admin module

commit 0fb74654c708a01bfaec8d552437e9f655bd325d
Author: Thibault 
Date:   Thu Jul 4 15:46:34 2013 +0200

   upgrade pymill version

…

Visualiser un dépot spécifique #C(id)

$ git show <commit>

Marquer un etat du dépot #tag(C)

git tag <mon_tag> # ex: stable

Annuler #C(*)=C(id)

$ git revert <commit_ID>

Branch & Head

Création d'une branche #B(master)➜NEW➜B(test)

$ git branch test

Deplacer head sur une branche #H(master)➜H(test)

$ git checkout test # Déplace HEAD sur "test"

Création d'une branche et déplacement du head #Alias

$ git checkout -b test #B(master)➜NEW➜B(test)+H(master)➜H(test)

Merge deux branches #H(test)➜H(master)+B(test)=B(master)

$ git checkout master #Deplacement sur branch master
$ git merge test #Deplacement du commit test vers master

Visualiser les branches existances #B(all)

$ git branch

• master
  test

Supprimer une branche #B(*)➜DELETE

$ git branch -d <branch>

Git checkout: details

$ git checkout <commit ou branche> # 1) Avec un identifiant de commit
$ git checkout <commit ou branche> <repertoire ou fichier > # 2) Avec un fichier / répertoire en plus
$ git checkout <repertoire ou fichier> # Équivalent à git checkout HEAD <repertoire ou branche>
$ git checkout # Équivalent à git checkout HEAD

Deplacer la référence de la branche courante #(H+C)=C(*)

$ git reset <commit id> #Plusieurs paramètres disponible, cf schéma

Dépots

Ajout d'un dépot

$ git remote add <alias> <url> (ex: origin master)

Suppression d'un dépot

$ git remote remove <alias>

Synchroniser le dépot principal en locale

$ git fetch <alias> <branch>

Ajoute les modifications local en haut de la liste des modifications à effectuer

$ git pull
$ git pull --rebase <alias> => upload

Telecharger les modifications sur git

$ git push <alias>
$ git push <alias> <branch>

Ignorer des fichiers

il faut créer un fichiers:.gitignore

Supprimer un git

$ git rm

GIT REBASE INCOMING

Qu'est-ce que cockpit ?

Cockpit est une interface graphique via navigateur web, open-source, destiné aux néophyte de linux comme aux administrateurs aguerris permettant d'administrer son serveur sous linux à distance. Celui-ci offre une manière d'effectuer des tâches simples d'administration.

Il est notamment possible grâce à Cockpit de gérer les services, les comptes utilisateurs, le pare-feu, arrêter ou redémarrer son système, gérer ses périphériques ou bien encore, utiliser directement un terminal dans l'interface graphique.

Si le projet vous intéresse, je vous invite à vous rendre sur la documentation officielle qui vous permettra d'approfondir toutes les possibilités offertes par Cockpit.

Installation de Cockpit

Pour installer Cockpit, celui-ci est nativement géré par la plupart des gestionnaires de paquet.

Sur des distributions basées sur Debian, ouvrer un terminal est entré la commande suivante :

sudo apt install cockpit

Vous pouvez vérifier que celui-ci est bien installé avec la commande :

systemctl is-active cockpit

Si celui-ci n'est pas activé, il faut démarrer le service à l'aide de la commande :

systemctl start cockpit

Accès à l'interface web de Cockpit

Si le service de cockpit est actif, il vous suffit maintenant de taper l'adresse IP de votre serveur suivi du port 9090 (port par défaut de Cockpit).

http://<adresse.ip.du.serveur>:9090 => http://192.168.1.10:9090

Configuration de Nginx pour accéder à Cockpit via à sous-domaine

Pour accéder à Cockpit depuis une adresse web, il faudra configurer nginx afin de diriger le traffic provenant du port 80 (ou 443 en HTTPS) vers le port 9090.

Pour cela, il faut ajouter une redirection à Nginx.

sudo touch /etc/nginx/sites-available/cockpit.votresousdomaine.ext

sudo nano /etc/nginx/sites-available/cockpit.votresousdomaine.ext

Configuration de cockpit.votresousdomaine.ext à copier/coller :

server {

listen 80;

listen [::]:80;


#cockpit.votresousdomaine.ext à remplacer pas votre domaine.

server_name cockpit.votresousdomaine.ext;

access_log /var/log/nginx/cockpit.log;

location / {

# Required to proxy the connexion to Cockpit

proxy_pass http://127.0.0.1:9090;

proxy_set_header Host $host;

proxy_set_header X-Forwarded-Proto $scheme;

# Required for web sockets to function

proxy_http_version 1.1;

proxy_buffering off;

proxy_set_header Upgrade $http_upgrade;

proxy_set_header Connection "upgrade";

# Pass ETag header from Cockpit to clients.

# See: https://github.com/cockpit-project/cockpit/issues/5239

gzip off;

}

}

Il vous faut ensuite à créer un fichier de configuration (si celui-ci n'existe pas déjà) pour cockpit à l'emplacement suivant /etc/cockpit/cockpit.conf et de copier la configuration suivante :

[WebService]

Origins = https://cockpit.votresousdomaine.ext wss://cockpit.votresousdomaine.ext

ProtocolHeader = X-Forwarded-Proto

Enfin, il ne vous reste qu'à crée un lien symbolique de votre fichier de configuration nginx depuis /etc/nginx/sites-available vers /etc/nginx/sites-enable et redémarrer nginx.

ln -s /etc/nginx/sites-available/cockpit.votresousdomaine.ext /etc/nginx/sites-enabled/

systemctl restart nginx

Vous devriez normalement avoir accès à cockpit depuis votre nom de domaine.

(Optionnel) Securiser Cockpit avec un accès HTTPS

Si vous voulez accéder à Cockpit de manière sécurisée, il est nécessaire de signer un certificat SSL avec Lets Encrypt. Pour cela, je vous conseille d'installer Certbot:

sudo apt install certbot python3-certbot-nginx

Et signer votre certificat avec la commande suivante :

sudo certbot --nginx -d /etc/nginx/sites-available/cockpit.votresousdomaine.ext

Et voilà, votre Cockpit est maintenant accessible et sécurisé.

Bonne administration à vous!

Raccourcis clavier du terminal

Commandes de terminal basique

Opérations sur les fichiers

Recherche de fichier(s)/dossier(s)

Expression régulière

Extraction, classement et filtre de la donnée

Programme en arrière-plan

Gestion des processus

Permission des fichiers/dossiers

Gestion des utilisateurs et groupes

Flux de redirection

Gestion des services

Nano

LES VARIABLES

// --------- TYPES NUMERIQUES ------------- //

    byte temperature; // -128 +127
     temperature = 64;

    short vitesseMax; // -32768 +32767
    vitesseMax = 32000;

    int temperatureSoleil; // -2*109 +2*109
    temperatureSoleil = 15600000; // kelvins
    
    long anneeLumiere; // -9*10^18 +9*10^18
    anneeLumiere = 9460700000000000L; // L à la fin
    
    float pi;
    pi = 3.141592653f;
    
    float nombre; // Nombre rond = x.Of 
    nombre = 2.0f;
    
    double division; // Pareil que Float, sauf que + de chiffres après la virgule
    division = 0.333333333333333333333333333333333333333333334d;

// --------- TYPES CARACTERE ------------- //

    char caractere;
    caractere = 'A';

// --------- TYPES BOOLEEN ------------- //
    
    boolean question;
    question = true;

// --------- TYPES STRING ------------- //  

    String phrase;
    phrase = "Titi et Grosminet";
    // OU 
    String str = new String();
    str = "Une autre chaîne de caractères";
    // OU
    String string = "Une autre chaîne";
    // OU
    String chaine = new String("Et une de plus !");

// --------------------- CONVERSION ------------------------------ // 
		
    int i = 123;
    float j = (float)i;
    
    int a = 123;
    double b = (double)i;
    
    double c = 1.23;
    double d = 2.9999999;
    int k = (int)c;        //k vaut 1
    k = (int)d;            //k vaut 2
		
// ------------------------------------------------------ //
// ----------------- ENTREE CLAVIER --------------------- //
// ------------------------------------------------------ //
		
    Scanner sc = new Scanner(System.in);
    System.out.println("Veuillez saisir un mot :");
    String saisi = sc.nextLine();
    System.out.println("Vous avez saisi : " + saisi);

    Scanner test = new Scanner(System.in);
    int a1 = sc.nextInt();
    double b1 = sc.nextDouble();
    long c1 = sc.nextLong();
    byte d1 = sc.nextByte();
    //Etc.

LES CONDITIONS

// --------------------------------------------------- //	 
// ------------------ OPERATEURS --------------------- //	
// --------------------------------------------------- //
	
    « == » : permet de tester l'égalité.

    « != » : permet de tester l’inégalité.

    « < » : strictement inférieur.

    « <= » : inférieur ou égal.

    « > » : strictement supérieur.

    « >= » : supérieur ou égal.

    « && » : l'opérateur ET. Il permet de préciser une condition

    « || » : le OU. Même combat que le précédent.

    «  ? : » : l'opérateur ternaire. Pour celui-ci, vous comprendrez mieux avec un exemple qui sera donné vers la fin de ce chapitre.

// --------------------------------------------------- //	 
// ------------------ CONDITIONS --------------------- //	
// --------------------------------------------------- //	 

// -------- IF > ELSE || IF > ELSE IF > ELSE ----------//

if(condition)
	{
//Exécution des instructions si la condition est remplie
	}
else
	{
//Exécution des instructions si la condition n'est pas remplie
	}
	
int i = 0; // Initialisaton de i à 0
    
if (i < 0)      // Si i inférieur à 0
	System.out.println("Ce nombre est négatif !");      
		  
else if(i > 0)  // Sinon si i supérieur à 0
	System.out.println("Ce nombre est positif !");           
		 
else            // Sinon 
	System.out.println("Ce nombre est nul !");
	
// IF AVEC OPERATEURS
		
int j = 58;
if(j > 50 && j < 100) 
	System.out.println("Le nombre est bien dans l'intervalle.");
else
	System.out.println("Le nombre n'est pas dans l'intervalle.");
	
		
// --------------------- SWITCH --------------------//
	
int note = 0; //On imagine que la note maximale est 20
switch (note)
	{
	case 0:
		System.out.println("Ouch !");
	break;
	case 10:
		System.out.println("Vous avez juste la moyenne.");
	break;
	case 20:
		System.out.println("Parfait !");
	break;
	default:
		System.out.println("Il faut davantage travailler.");
	}
	
String chaine = "Bonjour";
switch(chaine)
        {
	case "Bonjour":
	    System.out.println("Bonjour monsieur !");
	break;
	case "Bonsoir":
		System.out.println("Bonsoir monsieur !");
	break;
	default:
		System.out.println("Bonjoir ! :p");
	}
	
// ---------- CONDITION TERNAIRE ---------------- //
		
	int x = 10, y = 20;
	int max = (x < y) ? y : x ; //Maintenant, max vaut 20
    // Si condition renvoie true, la condition "? y" est affectée, sinon, ": x" est affectée.

LES BOUCLES

//-------------------------------------------------------------------------------//
//------------------------------ WHILE ------------------------------------------//
//-------------------------------------------------------------------------------//
		

    String prenom;          // Une variable vide
    char reponse = 'O';     // On initialise celle-ci à O pour oui

    Scanner sc = new Scanner(System.in);    // Notre objet Scanner, n'oubliez pas l'import de java.util.Scanner !
    while (reponse == 'O')                  // Tant que la réponse donnée est égale à oui…
	    {
	    System.out.println("Donnez un prénom : ");                          // On affiche une instruction
	    prenom = sc.nextLine();                                             // On récupère le prénom saisi
            System.out.println("Bonjour " +prenom+ ", comment vas-tu ?");       // On affiche notre phrase avec le prénom
            System.out.println("Voulez-vous réessayer ? (O/N)");	        // On demande si la personne veut faire un autre essai
            reponse = sc.nextLine().charAt(0);                                  // On récupère la réponse de l'utilisateur
	    }
    System.out.println("Au revoir…");
		
// Fin de la boucle
// On peut observer dans cette exemple que si l'on ne rentre pas "O" pour oui, celui ci sort de la boucle
		
		
//----------------------------- WHILE IMBRIQUE ----------------------------------//
				
    String prenom;
    char reponse = 'O'; // Besoin d'initialiser pour rentrer dans la boucle
	
    Scanner sc = new Scanner(System.in);
	
    while (reponse == 'O')
        {
        System.out.println("Donnez un prénom : ");
        prenom = sc.nextLine();
        System.out.println("Bonjour " +prenom+ ", comment vas-tu ?");                        
		
        reponse = ' '; // Sans ça, nous n'entrerions pas dans la deuxième boucle
		    
        while(reponse != 'O' && reponse != 'N') // Tant que la réponse n'est pas O ou N, on repose la question
            {
            System.out.println("Voulez-vous réessayer ? (O/N)"); // On demande si la personne veut faire un autre essai
            reponse = sc.nextLine().charAt(0);
            }  
        }
    System.out.println("Au revoir…");
		
// On peut utiliser la boucle DO... While (); pour ne pas avoir à reinitialiser réponse1. 
		
//-------------------------------------------------------------------------------//
//----------------------------------DO WHILE-------------------------------------//
//-------------------------------------------------------------------------------//
		
    String prenom = new String();
    char reponse = ' '; //Pas besoin d'initialiser : on entre au moins une fois dans la boucle !

    Scanner sc = new Scanner(System.in);
		 
    do{ // FAIT BOUCLE 1 (entrée dans la première boucle)
        System.out.println("Donnez un prénom : ");
        prenom = sc.nextLine();
        System.out.println("Bonjour " +prenom+ ", comment vas-tu ?");
		       
        do{ // FAIT BOUCLE 2 (entrée dans la deuxieme boucle)
            System.out.println("Voulez-vous réessayer ? (O/N)");
            reponse = sc.nextLine().charAt(0);
        }while(reponse != 'O' && reponse != 'N'); // TANT QUE BOUCLE 2 (fin de la deuxieme boucle)
    
    }while (reponse == 'O'); // TANT QUE BOUCLE 1 (fin de la première boucle)
    System.out.println("Au revoir…");
		
//-------------------------------------------------------------------------------//
//-------------------------------------FOR---------------------------------------//
//-------------------------------------------------------------------------------//	
		
    for(int i = 0, j = 2; (i < 10 && j < 6); i++, j+=2){ // Pour i = 0 et j = 2, tant que i < 10 et j > 6 alors, i+1 et J+2 
	     System.out.println("i = " + i + ", j = " + j);
		}
		
//-------------------------------------------------------------------------------//
//----------------------------PRIORITE OPERATEUR---------------------------------//
//-------------------------------------------------------------------------------//
    int a = 1, b = 15;
    while (a++ < b)
        System.out.println("coucou " +a+ " fois !!"); // Affiche 15 fois "coucou x fois!"
	
    System.out.println("FIN"); 
		
    int c = 1, d = 15;
    while (++c < d)
        System.out.println("coucou " +c+ " fois !!"); // Affiche 14 fois "coucou x fois!"
		
// a < b à la priorité sur l'opérateur a++ 
// ++c à la priorité sur l'opérateur c < d 

LES TABLEAUX

int tableauEntier[] = {0,1,2,3,4,5,6,7,8,9};
double tableauDouble[] = {0.0,1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0};
int tableauEntier1[] = new int[6]; // Tableau vide
//Ou encore
int[] tableauEntier2 = new int[6];
String tableauChaine[] = {"chaine1", "chaine2", "chaine3" , "chaine4"};

// -------------------------------------------------------------- // 

char tableauCaractere[] = {'a','b','c','d','e','f','g'};
		
    for(int i = 0; i < tableauCaractere.length; i++)
        {
        System.out.println("À l'emplacement " + i +" du tableau nous avons = " + tableauCaractere[i]);
        }
		
// -------------------------------------------------------------- // 
		
int premiersNombres[][] = { {0,2,4,6,8},{1,3,5,7,9} }, i = 0, j = 0;
// premiersNombres [0][2] = 4 
// premiersNombres [1][1] = 3 
		
System.out.println("La valeur du tableau est " + premiersNombres[0][2]+".");
			       
    while (i < 2) //P1// i = [O] //P2// i = [1]
        {
        j = 0; 
        while(j < 5) //P1// [i][j] = [0][0,1,2,3,4] //P2// [i][j] = [1][0,1,2,3,4]
            {
            System.out.print(premiersNombres[i][j]); //P1// 02468 //P2// 13579
            j++; 
            }
        System.out.println("");
        i++;
        }
		
// Pareil avec for
for(int i = 0; i < 2; i++)
    {    
    for(int j = 0; j < 5; j++)
        {
        System.out.print(premiersNombres[i][j]);       
        }
    System.out.println("");     
    }
		
// -------------------------------------------------------------- // 
		
String tab[] = {"toto", "titi", "tutu", "tete", "tata"};
	 
    for(String str : tab)
        System.out.println(str);
		
		
String tab[][]={{"toto", "titi", "tutu", "tete", "tata"}, {"1", "2", "3", "4"}};
int i = 0, j = 0;
		 
    for(String sousTab[] : tab) // La valeur de tab est mise dans sousTab
        {
        j = 0;
        for(String str : sousTab)
            {     
            System.out.println("La valeur de la nouvelle boucle est  : " + str);
            System.out.println("La valeur du tableau à l'indice ["+i+"]["+j+"] est : " + tab1[i][j]);
            j++;
            }
        i++;

LES METHODES

Par convention, les métodes s'ecrive avec un miniscule au départ, et majuscule ensuite, ex: getDate
On peut appeler une méthode d'instance pour un objet instancié d'une classe.
ex:

Voiture voiture1 = new Voiture();   // (Création d'une instance de la classe Voiture)
voiture1.getCouleur                 // On appelle la méthode getCouleur (qui est aussi un accesseur)

public static int somme(int nombre1, int nombre2) //somme est une méthode
{return (nombre1 + nombre2);
}

LA PORTEE

• Aucun mot cle: accessible par les classes du même paquetage ou package.
• Public: accessible par toutes les classes.
• Protected: accessibles par toutes les classes héritées et les classes du même paquetage, inaccessible aux autres.
• Private: inaccessible par toutes les autres classes.
• Static:
• Abstract:

CLASSES ET OBJETS

Par conventions les classes ont une majuscules.

Les variables de classes sont inchangeable, d'ou le static.

public class Point{

    public static double dimension = 2;     //VARIABLE DE CLASSE
    private double x;                       //VARIABLE D'INSTANCE
    private double y;                       //VARIABLE D'INSTANCE

    public Point(){                         //CONSTRUCTEUR PAR DEFAULT
        this(0,0);
    }

    public Point(double x, double y){       //CONSTRUCTEUR AVEC ARGUMENT
        this.setX(x);
        this.setY(y);
    }

    public double getX(){                   //ACCESSEURS X (METHODE)
        return this.x;
    }
    public double setX(double x){           //Point.setX(3) donne x = 3
        this.x = x; 
    }
     public double getY(){                   //ACCESSEURS Y (METHODE)
        return this.x;
    }
    public double setY(double y){           //Point.setY(6) donne y = 6
        this.y = y; 
    }
}

Cheat to Sheet - Summary

Cheat to Sheet - Java #1JAVA LES VARIABLES // --------- TYPES NUMERIQUES ------------- // byte temperature; // -128 +127 temperature = 64; short vitesseMax; // -32768 +32767 vitesseMax = 32000; int temperatureSoleil; // -2*109 +2*109 temperatureSoleil = 15600000; // kelvins long annee…

Noob to RootBertrand jve

Si vous faites preuve d'un sacré sens de l'observation (indice: le nom de l'article 🙃) vous pourriez vous doutez que ce site est auto-hébergé non pas sur un serveur appartenant à un tiers mais bien sur un Raspberry Pi, tranquillement branché à ma box internet de la maison.
En attendant le jour où celui-ci implosera lorsque plus de 3 personnes essaieront de se connecter au même moment sur ce site, je m'en vais vous rédiger un tutoriel sur comment héberger un serveur web sur un Raspberry Pi à la maison. Bonne lecture!

Pourquoi un Raspberry Pi?

Avant d'entamer les hostilités, il est selon moi important d'expliquer en quelques mots les raisons qui justifient ce choix. Il s'avère que je possède des Raspberry Pi depuis fort longtemps.

En l’occurrence, ma première expérience avec un Raspberry Pi fut avec le modèle 1B commercialisé en 2011. Celui-ci, glorieusement doté pour l’époque de 512 Mo de RAM et d'un CPU ARM cadencé à 700Mhz me fut acquis après une longue bataille auprès de ma génitrice à vanter les bienfaits et les possibilités quasi illimités que pouvait offrir un Raspberry Pi. La victoire me vint grâce au projet de transformer le Raspberry Pi en serveur multimédia sous XBMC (aujourd'hui renommé KODI) grâce à la distribution gnu/linux OpenElec. Le projet était de pouvoir lire des films dans le salon depuis l'unique PC familial directement depuis le réseau via le protocole UPnP (spoiler: celui-ci à finit dans ma chambre).

Seulement, avec l’avènement des services de streaming, l'idée d'un serveur multimédia peut aujourd'hui sembler anecdotique. Le Raspberry Pi a lentement mais surement commencé à prendre la poussière sous le meuble télévision en attendant sagement une seconde vie.

Ma deuxième expérience avec un Raspberry Pi fut cette fois ci à l'aide d'un Raspberry Pi modèle 3B commercialisé en 2016 doté d'un CPU quad cœur cadencé à 1,2Ghz et doté de 1Gb de RAM. Celui-ci fut impliqué dans différents projets d'apprentissage notamment système, à l'aide de la distribution gnu/linux Raspbian, dérivé de la très connu distribution Debian, mais également dans des projets plus axés réseaux avec l'installation d'OpenWRT, distribution gnu/linux historiquement conçu pour remplacer le firmware de différents routeurs.

Pour conclure cette partie, les Raspberry Pi sont de formidable outils qu'il s'agissent d'apprendre ou pour des projets plus conséquents. Je vous invite donc vivement à vous y intéressez plus amplement si vous ne connaissiez pas l'existence de ces petites machines, les articles parlant des milles et une façons d'exploiter son Raspberry Pi sont légions sur internet.
De mon côté, l'idée de rédiger un blog étant un projet de longue date, couplé avec mon attrait naturel pour les systèmes et réseaux en font un support idéal car peut consommateur d'énergie pour en apprendre plus sur les serveur web, et une superbe occasion de mêlée l'utile à l'agréable.

Petit disclaimer : le raspberry Pi est un micro-ordinateur, n'espérer donc pas pouvoir heberger un site web ayant le traffic du périphérique de Paris en heure de pointe. Celui-ci imploserait sur place. Si vous comptez heberger une application web subissant de lourds traitement, je vous invite à vous dirigez vers des services professionnels, ou d'heberger votre solution sur un ordinateur dédié ayant la puissance requise pour ce type de traitement.

Pré-requis:

• Un Raspberry Pi (modèle 3B minimum recommandé)
• Une carte SD (avec Raspbian ou Ubuntu Serveur)
• Une connexion Internet (privilégié le filiaire ethernet RJ45)
• Une connexion électrique
• (Optionnel) Un nom de domaine
• (Optionnel) Une addresse IP publique

Architecture

Etape 1 - Installation de l'OS

La première étape consiste à installer le système d'exploitation de votre Raspberry Pi sur votre carte SD.
Heureusement, cette étape est largement simplifié par la superbe équipe de la Raspberry Pi Fundation. Il vous suffit de vous rendre sur le site officiel de Raspberry Pi et d'y telecharger leur utilitaire d'installation d'ISO.

Une fois celui-ci installer, il vous suffit de selectionner votre carte SD fraichement inséré dans votre lecteur et d'y choisir l'OS de votre choix.
Dans mon cas, j'ai choisis Ubuntu Server 64bits sans interface graphique pour des raisons de compatibilités avec le CMS Open Source Ghost et afin d'alleger le serveur d'une interface graphique encombrante en terme de ressources utilisés, libre à vous d'installer l'interface graphique, mais pour le reste de ce tutoriel, je passerai par SSH afin d'administrer le serveur.

Une fois l'installation de votre OS sur votre carte SD terminé, il vous sera peut-être nécessaire de configurer le réseau wifi avant d'inserer la carte SD dans le raspberry pi. Si vous comptez vous brancher en filiaire ethernet, vous pouvez passer à l'étape suivante.
Pour cela, il vous suffit d'editer le fichier network-config localisé à la racine de votre carte SD et d'y ajouter le nom de votre réseau wifi ("home network) ainsi que la clé de sécurité ("123456789").

wifis:
  wlan0:
    dhcp4: true
    optional: true
    access-points:
      "home network":
        password: "123456789"

Il vous suffit maintenant d'inserer votre carte SD dans votre Raspberry Pi et d'allumer celui-ci.

Etape 2 - Configuration de base du serveur

Vous voici donc sur un Ubuntu Serveur fraichement installé.
Par defaut, l'utilisateur 'root' est désactivé sur Ubuntu. Le compte par default sur Ubuntu Serveur est l'utilisateur 'ubuntu' et son mot de passe est 'ubuntu'.

Il convient donc en premier lieu, pour des raisons de sécurité, de modifier le mot de passe de l'utilisateur ubuntu. Pour cela, il faudra rentrer la commande suivante:
sudo passwd ubuntu
Je ne saurais que fortement vous recommandez d'utiliser un mot de passe fort (8 charactères minimum, majuscules, minuscules, caractères Spéciaux, aucun mot entier) car votre Raspberry Pi sera exposé sur internet et donc potentielle proie de bots ou hackeurs malveillants.

La seconde etape consiste à mettre à jour votre raspberry pi à l'aide de la commande suivante:
sudo apt update && sudo apt upgrade

Votre serveur est maintenant configuré et à jour. Si vous utilisez votre Raspberry Pi directement depuis un écran, nous allons maintenant voir comment mettre en place le SSH pour nous connecter sur la console depuis un autre ordinateur.

Etape 3 - Installation du SSH

Pour les néophyte, le SSH est est à la fois un programme informatique et un protocole de communication sécurisé qui permet aux utilisateurs de contrôler et de modifier leurs serveurs distants sur Internet.

Le SSH pour Secure Shell devrait théoriquement être installé par défaut sur votre serveur, néanmoins, il convient de verifier si c'est le cas. Pour cela, vous pouvez utiliser la commande suivante:
systemctl status ssh.service
ou
systemctl is-active ssh.service

Si le serveur SSH est actif et installé, vous devriez obtenir le resultat suivant:

Dans le cas contraire, il vous faudra installé un serveur SSH. Dans ce cas, utilisez la commande suivante dans le terminal:
sudo apt install openssh-server

Si le SSH est correctement installé, il vous suffit maintenant d'obtenir l'addresse IP attribué à votre Raspberry Pi.

Pour cela utilisé la commande: ip a

Le resultat de notre commande nous renvoie 3 réseaux:

• Lo > Localhost, signifiant cet ordinateur, moi-même.
• Eth0 > Ethernet, réseau par cable Ethernet.
• Wlan0 > Wireless, réseau par wifi.

Noter l'adresse IP attribué (Eth ou Wlan). Elle vous permettra de vous connectez sur votre serveur depuis votre réseau local.
Pour cela, il vous suffit de taper la commande suivante depuis un autre PC de votre réseau local.
ssh ubuntu@<votre-addresse-ip>

Il ne vous reste qu'à rentrer le mot de passe utilisé lors de l'etape 2 et vous voila maintenant connecter en SSH sur votre serveur Raspberry Pi.

Etape 4 - Installation de Nginx

Maintenant que votre Raspberry Pi est accessible, il est maintenat nécessaire d'installer un logiciel de serveur web.
Pour les néophytes, un serveur web est un ordinateur qui stocke les fichiers qui composent un site web et qui s'occupe de renvoyer ses éléments à l'utilisateur qui visite le site.
En règle générale, on associe un domaine (ex: blog.noobtoroot.xyz) au serveur web.

Pour transformer votre Raspberry Pi en serveur Web, il vous faut donc installer un logiciel afin de transformer votre Raspberry Pi en serveur web.
Il en existe une multitude, les plus utilisés aujourd'hui sont:

• Apache
• ISS
• Nginx

Dans notre cas, nous utiliserons Nginx qui est selon moi, plus simple d'utilisation.

Pour installer nginx, il suffit d'utiliser le gestionnaire de package:
sudo apt install nginx

Nginx est maintenant installé sur votre serveur. Vous pouvez essayer d'entrer l'addresse IP de votre Rasperry Pi dans un navigateur en reseau local. Vous devriez voir apparaitre la page suivante:

Première partie pour tout apprendre sur l'IPv4, dans cette partie nous verrons comment traduire une adresse IP en binaire, comprendre les masques de sous-réseaux et enfin déterminer l'adresse de sous-réseaux afin d'en déduire l'adresse de broadcast ainsi que son nombre d'hôtes disponibles.

Qu'est-ce qu'une IP ?

L'adresse IP pour Internet Protocol désigne un numéro unique attribué de manière durable ou temporaire à un periphérique connecté à un réseau informatique.

Noté l'utilisation du terme "périphérique", en effet aujourd'hui, tout objet connecté à un réseau, de votre réfrigérateur connecté en passant évidemment par votre ordinateur possède une adresse IP.

Format d'une adresse IPv4 :

• 192.168.1.1

• 10.0.10.20

• 172.16.200.5

Une adresse IPv4 est composée de quatre octets de huit bits.

Prenons la première adresse IP de notre liste ci-dessus (192.168.1.1) en traduite en binaire, celle-ci équivaut à 11000000.10101000.00000001.00000001.

Il existe une multitude de façons de convertir un nombre décimal en binaire, aujourd'hui nombre de calculateurs pullules sur internet, mais comme la simplicité n'est pas à l'ordre du jour, nous allons voir dans la prochaine partie comment traduire une adresse IP en binaire.

Comment traduire l'addresse IP en binaire ?

Dans cette partie nous verrons deux méthodes pour convertir notre IP en binaire.

La première, plus algébrique, transforme un nombre décimal (base 10) en binaire (base 2), la seconde quant à elle, use d'un tableau et de quelques additions ou soustractions.

Methode 1 - Conversion par division

La première méthode se base sur une division par deux et du reste pour la conversion en binaire. Dans les faits, nous prenons le nombre entier que nous divisons par deux, si le résultat est un nombre entier, le bit sera à 0. Dans le cas ou le résultat retourne un nombre décimal, le bit sera à 1.

Prenons comme exemple le nombre 42.

Lorsque l'on divise celui-ci par 2, le résultat nous donne 21. Le dernier bit sera donc à 0. Divisons maintenant 21, le réultat est cette fois ci de 10,5. L'avant dernier bit sera à 1. Il faut ensuite répéter l'opération avec 10 (sans compter la décimal restante) et ainsi de suite jusqu'à arriver à 0.

42 / 2 = 21+0
21 / 2 = 10+1
10 / 2 = 5+0
5 / 2 = 2+1
2 / 2 = 1+0
1 / 2 = 0+1
Attention, il faut bien lire de bas en haut !

Le resultat en binaire est 101010.

Methode 2 - Conversion à l'aide d'un tableau

La deuxième méthode se base sur un tableau des puissances de deux pour effectuer une addition ou une soustraction de notre nombre décimal afin d'obtenir notre binaire.

Cette méthode, bien que plus longue à mettre en place, à l'avantage d'être assez visuelle. De plus, celle-ci est plus adapté aux prochaines étapes qui nous attendent, pour la suite du tutoriel nous allons continuer d'utiliser cette méthode.

Une image vaut mille mots, nous allons directement passer par un exemple pour comprendre cette méthode, celle-ci parlant d'elle-même.

Prenons l'adresse IP suivante:

236.192.0.1

Nous aurons besoin de ce tableau pour procéder à la méthode:

Deux possibilités s'offrent à nous, l'addition ou la soustraction.

Dans la cadre de l'addition, il faut arriver aux résultatsdécimaux pour chaque octet de notre IP à l'aide de notre tableau des puissances de 2.

Dans le cas présent,voici le résultat:

• 236 = 128 + 64 + 32 + 8 + 1
• 192 = 128 + 64
• 0 = 0
• 1 = 1

Pour la soustraction, il faut soustraire à notre nombre décimal les puissances de deux jusqu'à arriver à 0 et ajouter les bits au tableau. Si une soustraction retourne un nombre négatif, on considère le bit à 0 et le nombre décimal doit être déporté à la prochaine puissance de deux qui retourne un nombre positif.

• 236
  (236 - 128 = 108) => 1
  (108 - 64 = 44) => 1
  (44 - 32 = 12) => 1
  (12 - 16 = -4) => 0
  (12 - 8 = 4) => 1
  (4 - 4 = 0) => 1
  (0 - 2 = -2) => 0
  (0 - 1 = -1) => 0
  Résultat de 236 = 11101100.
• 192
  (192 - 128 = 64) => 1
  (64 - 64 = 0) => 1
  Arrivé à 0, donc tous les bits suivant seront négatif.
  Résultat de 192 = 11000000.
• 0
  Aucun bit ne sera positif.
  Résultat de 0 = 00000000.
• 1
  Seul la puissance 2^1 sera positif.
  Résultat de 1 = 00000001.

Le traduction binaire sera 11101100.11000000.00000000.00000001.

Qu'est-ce que le masque de sous réseaux ?

Le masque de sous réseaux permet de découper notre IP en réseaux et hôtes (ou machines).

C'est-à-dire qu'une partie de l'adresse IP sera réservé afin de segmenter plusieurs sous-réseaux dans lesquelles nous pourrons attribuer des machines.

Aujourd'hui, une adresse IPv4 peut-utiliser deux notations :

• Décimale : 255.255.255.255, 255.0.0.0, 255.255.248.0, etc.

• CIDR (Classless Inter Domain Routing) : /8, /16, /22, /24, etc.

En l'occurence, la notation CIDR comprend l'adresse IP et son masque de sous réseau.

Exemple: '192.168.0.1/24' = '192.168.0.1, 255.255.255.0'

S'il vous prend de calculer le masque de sous-réseau en binaire, celui-ci se convertit de la même manière qu'une adresse IP.

Classe d'adresse d'IP publique et privée

Maintenant que le terme de masque de sous-réseau a été abordé, il est important de définir ce que représente une adresse IP publique et privée.

Lorsque l'on parle d'adresse IP publique, celle-ci se découpe en classe. En tout cinq classes d'adresses IP sont définis, mais nous en verrons que trois dans le cadre de ce cours.

En observant le tableau, on peut constater qu'il ya une forte disparité entre les trois classes d'adresse IP.

Prenons l'exemple de la classe A. Si l'on convertit une adresse IP de classe A en binaire (R=Réseau;O=Ordinateur : RRRRRRRR.OOOOOOOO.OOOOOOOO.OOOOOOOO) vous pouvez facilement observer que la majorité des octets de l'adresse IP sont réservés aux machines hôtes (ordinateur) et non aux réseaux. L'adresse IP de type B (RRRRRRRR.RRRRRRRR.OOOOOOOO.OOOOOOOO) elle semble plus équilibré. Quant aux machines de classes C, le nombre de machines hôtes est très limité.

Ce découpage hasardeux à entrainé bon nombre d'assignation d'adresse IP publique de classe A (donc 16 millions d'adresses IP potentielles) à des entreprises qui n'en ont pas de réel besoins, entrainant désormais une pénurie d'adresse IPv4 sur internet.

En plus du nombre d'adresse IP publique maximum limité, ajouté à cette liste des adresses réservés afin d'être utilisé dans des réseaux privés.

• 127.0.0.1 > Loopback
• 172.16.0.0 - 172.31.255.255 > Local
• 10.0.0.0 - 10.255.255.255 > Local
• 192.168.0.0 - 192.168.255.255 > Local

Aujourd'hui, plusieurs solutions ont été adoptées afin de palier à ce problème, notamment le NAT (Network Addresse Translation) et l'IPv6 qu'on abordera dans un tutoriel ultérieur.

Comment déterminer l'adresse de sous réseau ?

Pour déterminer le réseau d'une adresse IP nous avons besoin de l'adresse IP et du masque de sous réseau traduit en binaire.

Pour cela nous allons utiliser un nouveau tableau qui va superposer l'IP et le masque de sous réseau et remplir par un ET logique la dernière rangée du tableau. Les règles sont donc :

R = (IP) AND (M)

• 1+1=1
• 1+0=0
• 0+1=0
• 0+0=0

Exemple:

192.168.1.1/24

L'adresse du réseau 192.168.1.1/24 est 192.168.1.0/24.

Comment calculer l'adresse de broadcast ?

Pour calculer l'adresse de broadcast, nous avons besoin de l'adresse du réseau ainsi que du masque de sous réseau que l'on inversera.

Nous allons utiliser une nouvelle fois le tableau précèdent, mais en superposant cette fois-ci l'adresse du réseau et le masque de sous réseau inversé et procédé à un OU logique. Les règles sont donc :

B = R OR !(M) <- !(M) = Masque de réseau inversé.

• 1 +1 = 1
• 1 + 0 = 1
• 0 + 1 = 1
• 0 + 0 = 0

192.168.1.0/24

L'addresse de broadcast du réseau 192.168.1.0/24 est 192.168.1.255.

Comment déterminer le nombre d'hôtes d'un réseau ?

Afin de calculer le nombre d'hôte sur un réseau, nous devons déterminer l'adresse IP de notre réseaux et inverser le binaire des bits utiliser par le masque de sous réseaux.

Exemple :

192.168.1.0/20

'/20' correspond à 11111111.11111111.11110000.00000000. (=255.255.240.0)

Si l'on inverse le masque de sous réseaux, cela nous donne.

00000000.00000000.00001111.11111111

• 00001111 : 8+4+2+1 = 15

• 11111111 : 128+64+32+16+8+4+2+1 = 255

Résultat : 270 hôtes.

Mais il nous manque un petit quelque chose... L'adresse du réseau et l'adresse de broadcast.

En l'occurrence, 192.168.1.0 est 192.168.1.255. En effet, ces deux adresses sont réservées afin de définir le réseau avec 192.168.1.0 et envoyer un message en broadcast (diffuser à tout le monde sur le réseau) au 192.168.1.255.

Il y a donc 268 hôtes possible sur notre réseau 192.168.1.0/20.

Noob to Network

Noob to IPv4 #1Première partie pour tout apprendre sur l’IPv4, dans cette partie nous verrons comment traduire une addresse IP en binaire, comprendre les masques de sous-réseaux et enfin determiner l’addresse de sous-réseaux afin d’en déduire l’addresse de broadcast ainsi que son nombre d’hôtes disp…

Noob to RootBertrand jve