OpenJDK est une implémentation open source de la plate-forme de développement Java. Il s'agit d'un projet collaboratif qui est géré par Oracle et soutenu par une communauté mondiale de développeurs. OpenJDK est composé d'un ensemble de bibliothèques, d'outils de développement et d'une machine virtuelle Java (JVM).

L'objectif d'OpenJDK est de fournir une implémentation gratuite et open source de Java, permettant à la communauté de développeurs de participer à l'évolution de la plate-forme Java et de proposer des améliorations. En plus de cela, OpenJDK offre également une alternative à la version propriétaire de Java de Oracle.

De nombreuses distributions Linux incluent OpenJDK comme leur implémentation de Java par défaut. Les développeurs peuvent également télécharger et installer OpenJDK directement depuis le site web d'OpenJDK.

Installez OpenJDK 11.

[1] Si vous n'avez besoin que de JRE, installez uniquement le package [java-11-openjdk],

mais si vous avez besoin d'un compilateur, installez également le package [java-11-openjdk-devel].

[root@clubti ~]# dnf -y install java-11-openjdk java-11-openjdk-devel

[root@clubti ~]# cat > /etc/profile.d/java.sh <<'EOF'

export JAVA_HOME=$(dirname $(dirname $(readlink $(readlink $(which java)))))

export PATH=$PATH:$JAVA_HOME/bin

EOF

[root@clubti ~]# source /etc/profile.d/java.sh

[root@clubti ~]# java --version

openjdk 11.0.10 2021-01-19 LTS

OpenJDK Runtime Environment 18.9 (build 11.0.10+9-LTS)

OpenJDK 64-Bit Server VM 18.9 (build 11.0.10+9-LTS, mixed mode, sharing)

# vérifier pour créer un programme de test

[root@clubti ~]# cat > java_test.java <<'EOF'

class java_test {

    public static void main(String[] args) {

        System.out.println("Hello Java World !");

    }

}

EOF 

[root@clubti ~]# javac java_test.java

[root@clubti ~]# java java_test

Hello Java World !

[2] Si vous avez installé plusieurs versions de Java à partir du référentiel officiel CentOS, il est possible de les changer avec [alternatives].

[root@clubti ~]# alternatives --config java

There are 2 programs which provide 'java'.

  Selection    Command

-----------------------------------------------

   1           java-11-openjdk.x86_64 (/usr/lib/jvm/java-11-openjdk-11.0.10.0.9-8.el8.x86_64/bin/java)

*+ 2           java-1.8.0-openjdk.x86_64 (/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.282.b08-4.el8.x86_64/jre/bin/java)

Enter to keep the current selection[+], or type selection number: 1

[root@clubti ~]# alternatives --config javac

There are 2 programs which provide 'javac'.

  Selection    Command

-----------------------------------------------

   1           java-11-openjdk.x86_64 (/usr/lib/jvm/java-11-openjdk-11.0.10.0.9-8.el8.x86_64/bin/javac)

*+ 2           java-1.8.0-openjdk.x86_64 (/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.282.b08-4.el8.x86_64/bin/javac)

Enter to keep the current selection[+], or type selection number: 1

[root@clubti ~]# java --version

openjdk 11.0.10 2021-01-19 LTS

OpenJDK Runtime Environment 18.9 (build 11.0.10+9-LTS)

OpenJDK 64-Bit Server VM 18.9 (build 11.0.10+9-LTS, mixed mode, sharing)

[root@clubti ~]# javac --version

javac 11.0.10

Tutoriel pour l'installation :

Docker est une plateforme de conteneurs qui permet d'emballer des applications dans des conteneurs logiciels pour faciliter leur déploiement, leur exécution et leur gestion sur différents environnements.

Concrètement, Docker permet de créer des conteneurs qui encapsulent une application, ses dépendances et son environnement d'exécution, ce qui permet d'assurer une portabilité et une cohérence des applications à travers différents environnements (du développement à la production).

Les conteneurs Docker sont légers, rapides et isolés les uns des autres, ce qui permet de les déployer rapidement et efficacement, et de simplifier la gestion des applications. Docker est devenu un outil incontournable pour le développement et le déploiement d'applications modernes, notamment dans les environnements Cloud.

Pour installer Docker sur CentOS, vous pouvez suivre les étapes suivantes :

1. Mettre à jour le système :

   sqlCopy code
   sudo yum update
   

2. Installer les dépendances nécessaires :

   kotlinCopy code
   sudo yum install -y yum-utils device-mapper-persistent-data lvm2
   

3. Ajouter le référentiel Docker :

   csharpCopy code
   sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
   

4. Installer Docker :

   luaCopy code
   sudo yum install docker-ce docker-ce-cli containerd.io
   

5. Démarrer le service Docker :

   sqlCopy code
   sudo systemctl start docker
   

6. Vérifier que Docker est en cours d'exécution :

   luaCopy code
   sudo systemctl status docker
   

7. Ajouter votre utilisateur au groupe Docker (optionnel) :

   phpCopy code
   sudo usermod -aG docker <votre_utilisateur>
   

   Cette étape permet à votre utilisateur d'exécuter des commandes Docker sans avoir à utiliser sudo à chaque fois.

C'est tout ! Vous pouvez maintenant utiliser Docker sur votre système CentOS.

Les administrateurs système peuvent gérer les conteneurs Docker de plusieurs façons, notamment :

1. Démarrer et arrêter des conteneurs : Les administrateurs système peuvent utiliser la commande "docker start" pour démarrer un conteneur et "docker stop" pour l'arrêter.

2. Visualiser les conteneurs en cours d'exécution : La commande "docker ps" permet d'afficher tous les conteneurs en cours d'exécution.

3. Créer de nouveaux conteneurs : Les administrateurs système peuvent créer de nouveaux conteneurs en utilisant la commande "docker run". Cette commande permet de spécifier une image Docker à utiliser pour créer un nouveau conteneur.

4. Accéder aux logs de conteneurs : Les administrateurs système peuvent accéder aux logs des conteneurs en utilisant la commande "docker logs". Cela permet de diagnostiquer les problèmes éventuels dans les conteneurs.

5. Gérer les réseaux : Les administrateurs système peuvent créer, modifier et supprimer des réseaux Docker en utilisant la commande "docker network".

6. Gérer les images : Les administrateurs système peuvent gérer les images Docker en utilisant les commandes "docker pull" pour télécharger une image, "docker push" pour publier une image, et "docker rmi" pour supprimer une image.

7. Gérer les volumes : Les administrateurs système peuvent gérer les volumes Docker en utilisant les commandes "docker volume create" pour créer un nouveau volume, "docker volume ls" pour afficher tous les volumes, et "docker volume rm" pour supprimer un volume.

En outre, les administrateurs système peuvent utiliser des outils de gestion de conteneurs Docker tels que Docker Compose ou Kubernetes pour simplifier la gestion des conteneurs sur un grand nombre de machines.

Voici quelques meilleures pratiques à suivre lors de la création d'images Docker personnalisées à l'aide de Dockerfiles :

1. Utiliser les instructions "FROM" et "TAG" : La première instruction d'un Dockerfile doit être "FROM" pour spécifier l'image de base à utiliser. Vous devriez également utiliser l'instruction "TAG" pour spécifier la version de l'image de base que vous utilisez.

2. Utiliser un nommage approprié pour l'image : Le nom de l'image doit être significatif et facile à comprendre. Il devrait être en minuscules et séparé par des tirets.

3. Minimiser le nombre de couches : Le nombre de couches dans une image peut affecter les performances et la sécurité. Il est donc recommandé de minimiser le nombre de couches en combinant des commandes similaires en une seule couche.

4. Utiliser "COPY" plutôt que "ADD" : L'instruction "COPY" est préférable à l'instruction "ADD" car elle est plus simple et ne prend pas en charge les fichiers d'URL.

5. Éviter les dépendances inutiles : Les images doivent être aussi légères que possible, il est donc important d'éviter les dépendances inutiles. Cela peut être fait en supprimant les fichiers temporaires et en nettoyant les caches après l'installation des paquets.

6. Éviter d'utiliser "RUN" pour plusieurs commandes : Utiliser une seule commande "RUN" pour plusieurs commandes peut créer de nombreuses couches et rendre l'image plus grande. Il est préférable d'utiliser des && pour exécuter plusieurs commandes dans une seule instruction "RUN".

7. Définir un point d'entrée : Le point d'entrée spécifie la commande à exécuter lorsqu'un conteneur est démarré à partir de l'image. Il est recommandé de définir un point d'entrée pour améliorer la sécurité et la facilité d'utilisation.

8. Utiliser des fichiers .dockerignore : Les fichiers .dockerignore sont utilisés pour spécifier les fichiers et les répertoires qui ne doivent pas être inclus dans l'image. Cela peut aider à réduire la taille de l'image et à améliorer les performances.

9. Mettre à jour régulièrement les images : Les images doivent être régulièrement mises à jour pour inclure les dernières mises à jour de sécurité et les correctifs. Il est donc important de garder une trace des images et de mettre à jour régulièrement celles que vous utilisez.

En suivant ces meilleures pratiques, vous pouvez créer des images Docker personnalisées efficaces, sécurisées et faciles à utiliser.

Le réseau Docker est un sous-système de Docker qui permet aux conteneurs Docker de communiquer entre eux et avec l'extérieur. Il est conçu pour être flexible, modulaire et facile à utiliser.

Voici comment le réseau Docker fonctionne :

1. Création de ponts de réseau : Lorsqu'un conteneur Docker est créé, Docker crée automatiquement un pont de réseau virtuel, qui est un réseau privé interne au système hôte. Ce pont de réseau permet à tous les conteneurs de communiquer entre eux.

2. Attribution d'adresses IP : Chaque conteneur Docker reçoit une adresse IP unique à partir d'un sous-réseau privé spécifié par l'utilisateur. Les adresses IP peuvent être attribuées manuellement ou automatiquement par Docker.

3. Utilisation de liens de conteneur : Les conteneurs peuvent être liés les uns aux autres, créant ainsi une connexion réseau entre eux. Les liens de conteneur permettent à un conteneur d'accéder aux ports exposés d'un autre conteneur.

4. Exposition de ports : Les ports d'un conteneur peuvent être exposés à l'extérieur du conteneur, permettant ainsi à d'autres conteneurs ou à l'extérieur d'accéder aux services en cours d'exécution dans le conteneur.

5. Utilisation de réseaux personnalisés : Docker permet également la création de réseaux personnalisés, qui sont des réseaux privés isolés du réseau par défaut de Docker. Les réseaux personnalisés peuvent être utilisés pour isoler les conteneurs et contrôler l'accès aux services.

6. Configuration de la sécurité : Docker fournit également des fonctionnalités de sécurité pour les réseaux Docker, notamment la segmentation de réseau et l'isolation de conteneurs pour protéger les conteneurs et les données.

En résumé, le réseau Docker est un sous-système essentiel de Docker qui permet aux conteneurs de communiquer entre eux et avec l'extérieur. Les fonctionnalités du réseau Docker, notamment les ponts de réseau, les adresses IP, les liens de conteneur et les réseaux personnalisés, offrent une grande flexibilité pour créer des environnements de conteneurs personnalisés et sécurisés.

Pour fabriquer vos propres conteneurs et images Docker, vous devez suivre les étapes suivantes :

1. Écrire un fichier Dockerfile : Un Dockerfile est un fichier texte qui contient des instructions pour construire une image Docker. Les instructions peuvent inclure des commandes pour installer des packages, configurer des paramètres de l'application, etc.

2. Créer une image Docker : Une fois que vous avez créé le fichier Dockerfile, vous pouvez utiliser la commande "docker build" pour construire une image Docker à partir de ce fichier. Cette commande va exécuter chaque instruction du Dockerfile, une par une, pour créer l'image.

3. Créer un conteneur à partir de l'image : Une fois que vous avez créé une image Docker, vous pouvez créer un conteneur à partir de cette image en utilisant la commande "docker run". Cette commande va lancer une instance du conteneur à partir de l'image que vous avez créée.

4. Personnaliser le conteneur : Vous pouvez personnaliser le conteneur en modifiant les fichiers et les paramètres de configuration. Vous pouvez également exécuter des commandes dans le conteneur en utilisant la commande "docker exec".

5. Enregistrer l'image : Une fois que vous avez personnalisé le conteneur, vous pouvez enregistrer les modifications en créant une nouvelle image à partir du conteneur. Cette image peut ensuite être utilisée pour créer d'autres conteneurs.

Voici quelques conseils à suivre lors de la création de vos propres conteneurs et images Docker :

• Utilisez des images de base légères pour minimiser la taille de l'image finale.
• Essayez de minimiser le nombre d'instructions dans le fichier Dockerfile pour faciliter la compréhension et la maintenance.
• Utilisez des variables d'environnement pour faciliter la personnalisation du conteneur.
• Évitez d'utiliser des mots de passe en dur dans les fichiers Dockerfile ou les images.
• Utilisez le fichier .dockerignore pour exclure les fichiers inutiles de l'image Docker.

En suivant ces conseils et en pratiquant régulièrement la création de conteneurs et d'images Docker, vous pourrez rapidement devenir un expert dans la construction d'environnements de conteneurs personnalisés.

Voici un exemple simple de Dockerfile qui utilise une image de base Ubuntu pour créer une nouvelle image contenant une application Flask :

sqlCopy code
FROM ubuntu:latest

RUN apt-get update && \
    apt-get install -y python3-pip && \
    pip3 install --no-cache-dir flask

WORKDIR /app

COPY . .

CMD ["python3", "app.py"]

Ce Dockerfile contient les instructions suivantes :

• FROM : spécifie l'image de base à utiliser, dans ce cas, la dernière version d'Ubuntu.

• RUN : exécute des commandes pendant la création de l'image. Ici, nous mettons à jour les paquets et installons Python 3 et Flask à l'aide de pip.

• WORKDIR : définit le répertoire de travail pour les instructions suivantes.

• COPY : copie les fichiers locaux dans le répertoire de travail de l'image.

• CMD : définit la commande par défaut qui sera exécutée lorsque le conteneur sera démarré. Dans ce cas, nous lançons notre application Flask.

Ce Dockerfile crée une nouvelle image qui contient une application Flask. Pour construire l'image, vous pouvez utiliser la commande docker build. Voici un exemple de commande :

Copy code
docker build -t nom_image .

L'option -t permet de spécifier le nom de l'image que vous voulez créer et le . indique le répertoire local qui contient le fichier Dockerfile.

Une fois que l'image est créée, vous pouvez lancer un conteneur à partir de celle-ci en utilisant la commande docker run. Voici un exemple de commande :

cssCopy code
docker run -p 5000:5000 nom_image

L'option -p permet de mapper le port 5000 du conteneur à un port disponible sur l'hôte local. Cela permet d'accéder à l'application Flask à partir du navigateur en accédant à l'URL http://localhost:5000.