Pour ce premier projet de NSI d’art génératif, nous avons décidé de représenter un micro, un BM 800 avec le module turtle de python.
La vidéo du projet :
Pourquoi le micro ?
Tout simplement car Mathieu fait de la musique plus précisément des instrumentales et Romain lui fait de l’audiovisuel (photos et vidéos). Le micro qui est indispensable dans ces 2 univers. Nous avons choisi le micro BM 800 car pour débuter c’est l’un des meilleurs micros.
Le projet
Pour en revenir au projet, nous avons décidé de faire un micro. Pour cela nous avons utilisé le module turtle ainsi que le module random.
Structure du script
Pour la structure du script nous avons décidé de découper chaque partie de l’image (fond, albums vinyles, cors du micro, prise XLR et bonnette du micro) pour créer des fonctions et pour organiser le script.
Analyse du script
Nous allons analyser le script :
nous allons commencer par par l’appel des modules et la mise en place de turtle :
from turtle import *
from random import randint
"""
Ce fichier est expliqué ici : https://nsi.xyz/py2png
Un autre tutoriel permet de commencer : https://nsi.xyz/tutoriels/decouvrir-le-module-turtle-de-python/
"""
try:
from PIL import Image
pillow_installed = True
except:
print("Oops! - ModuleNotFoundError: No module named 'PIL' - RTFM :")
print("https://nsi.xyz/py2png")
pillow_installed = False
# Uniquement des lettres, des chiffres, un tiret. Rien d'autre.
# https://learn.microsoft.com/fr-fr/windows/win32/fileio/naming-a-file
titre = "micro bm800 - construit avec turtle"
# Définir le titre de la fenêtre de turtle + propagande ^^
title(titre+" | Au lycée, la meilleure spécialité, c'est la spé NSI")
# definir la taille de la fenêtre en 720p (Largeur, Hauteur)
# La tortue part du centre, au point de coordonnées (0,0)
setup(1280, 720)
# La tortue va à la vitesse du lièvre et active sa cape d'invisibilité
speed(0)
hideturtle()
"""NOUVEAUTE 2023 :
Pour un tracé instantané, sans aucun délai,
il suffit d'affecter la valeur True à la variable "flash" (False par défaut)
mais cela rend le débuggage moins facile
Merci @bebertii
"""
flash = True # False par défaut, on peut mettre True sinon, ou mieux 0x2A
if flash:
wn = Screen()
wn.tracer(0)
Ensuite pour le fond nous avons utilisé une fonction qui se nomme background-color. Nous avons défini avec la couleur bleu marine en hexadécimal.
def fond():
bgcolor("#03224c")
Ce qui nous donne :
Après nous avons fait le corps du micro avec quelques valeurs tel que la couleur, la longueur et la largeur du rectangle. Puis nous avons défini une position à laquelle le corps du micro va se positionner, nous avons tracé un rectangle noir, puis nous avons tracé un trapèze pour représenter le bout du micro.
import turtle
ht()
def corpmicro():
t = turtle.Turtle()
col = ("#000000")
l = 100
la = 200
t.goto(-100,0)
t.fillcolor(col)
t.begin_fill()
t.ht()
for i in range(2):
t.forward(l)
t.right(90)
t.forward(la)
t.right(90)
t.end_fill()
t.begin_fill()
t.penup()
t.rt(90)
t.forward(la)
t.pendown()
t.left(45)
t.forward(40)
t.left(45)
t.forward(44)
t.left(45)
t.forward(40)
t.end_fill()
Ce qui nous donne avec le fond :
Après cela, pour la prise XLR, nous avons réalisé une fonction prise XLR puis nous avons tracé un rectangle gris et nous lui avons donné une position finale.
def prisexlr():
p = turtle.Turtle()
col3 = ("#c4c4c4")
l7 = 44
la6 = 20
p.ht()
p.penup()
p.goto(-72,-228)
p.pendown()
p.fillcolor(col3)
p.begin_fill()
for i in range(2):
p.forward(l7)
p.right(90)
p.forward(la6)
p.right(90)
p.end_fill()
Ce qui nous donne avec le fond et le corps du micro :
Ensuite pour les 2 albums vinyles, nous avons fait 2 fonctions distincts pour chacun des 2 albums vinyles dans lesquels nous avons rentré les même valeurs tel que les couleurs et le rayon des 2 cercles qui compose l’album vinyle ainsi que la longueur du carré. Ensuite nous avons juste modifié les positions des cercles et carrés.
1er album vinyle :
def albumvinyle():
a = turtle.Turtle()
col4 = ("#000000")
col5 = ("#2f4f4f")
col6 = ("#f9429e")
l8 = 80
r = 35
r2 = 35/2
a.penup()
a.goto(-400,300)
a.pendown()
a.fillcolor(col5)
#carton de l'album
a.begin_fill()
for i in range (4):
a.forward(l8)
a.right(90)
a.end_fill()
#vinyle
a.penup()
a.goto(-360,225)
a.pendown()
a.fillcolor(col4)
a.begin_fill()
a.circle (r2)
a.end_fill()
#centre du vinyle
a.penup()
a.goto(-360,242)
a.pendown()
a.fillcolor(col6)
a.ht()
a.begin_fill()
2e album vinyle :
def albumvinyle2():
a = turtle.Turtle()
col4 = ("#000000")
col5 = ("#2f4f4f")
col6 = ("#f9429e")
l8 = 80
r = 35
r2 = 35/2
a.penup()
a.goto(360,-220)
a.pendown()
a.fillcolor(col5)
#carton de l'album
a.begin_fill()
for i in range (4):
a.forward(l8)
a.right(90)
a.end_fill()
#vinyle
a.penup()
a.goto(400,-295)
a.pendown()
a.fillcolor(col4)
a.begin_fill()
a.circle (r2)
a.end_fill()
#centre du vinyle
a.penup()
a.goto(400,-277)
a.pendown()
a.fillcolor(col6)
a.ht()
a.begin_fill()
a.circle (r2)
a.end_fill()
Ce qui nous donne avec le fond, le corps du micro et la prise XLR :
De plus pour la bonnette du micro, nous avons défini un rectangle noir pour faire ressortir le quadrillage gris de la bonnette.
def bonettefond():
#fond permetant de faire un quadrillage noir
b = turtle.Turtle()
col2 = ("#000000")
l2 = 125
la2 = 150
b.penup()
b.goto(-225/2,150)
b.pendown()
b.fillcolor(col2)
b.ht()
b.begin_fill()
for i in range(2):
b.forward(l2)
b.right(90)
b.forward(la2)
b.right(90)
b.end_fill()
Ensuite pour la grille de la bonnette, nous avons fait le quadrillage de la bonnette pour cela nous avons réalisé une fonction qui va permettre de faire des lignes horizontales et verticales.
def bonettegrille():
g = turtle.Turtle()
col3 = ("#c4c4c4")
l3 = 150
la3 = 4
l4 = 125
g.penup()
g.goto(-230/2,150)
g.pendown()
g.fillcolor(col3)
g.begin_fill()
g.ht()
#grille horizontale
for i in range(16):
g.right (90)
g.forward(l3)
g.left(90)
g.forward(la3)
g.left(90)
g.forward(l3)
g.right(90)
g.forward(la3)
g.right(90)
#grille verticale
for i in range(19):
g.right (90)
g.forward(l4)
g.left(90)
g.forward(la3)
g.left(90)
g.forward(l4)
g.right(90)
g.forward(la3)
g.end_fill()
Et pour finir pour les barres de la bonnette, nous avons créer une fonction qui va nous permettre de faire 4 rectangles de longueurs et de largeurs différentes et aussi de positions différentes pour créer les barres de la bonnette.
def barrebonette():
bo = turtle.Turtle()
col3 = ("#c4c4c4")
l5 = 127
la4 = 25
l6 =6
la5 =145
bo.penup()
bo.goto(-230/2,145)
bo.pendown()
bo.fillcolor(col3)
bo.ht()
#première barre horizontale
bo.begin_fill()
for i in range(2):
bo.forward(l5)
bo.right(90)
bo.forward(la4)
bo.right(90)
bo.end_fill()
bo.goto(-230/2,25)
#deuxième barre horizontale
bo.begin_fill()
for i in range(2):
bo.forward(l5)
bo.right(90)
bo.forward(la4)
bo.right(90)
bo.end_fill()
bo.goto(-232/2,145)
#première barre vertical
bo.begin_fill()
for i in range(2):
bo.forward(l6)
bo.right(90)
bo.forward(la5)
bo.right(90)
bo.end_fill()
bo.goto(10,145)
#deuxième barre vertical
bo.begin_fill()
for i in range(2):
bo.forward(l6)
bo.right(90)
bo.forward(la5)
bo.right(90)
bo.end_fill()
Ce qui nous donne avec juste la bonnette et le fond :
De plus, nous avons une fonction très importante qui sert pas à dessiner quelque chose mais elle rassemble toutes les fonctions afin de les mettre dans le bonne ordre. Donc cela nous a permis de faire chacun nos fonctions chez nous et les mettre en commun.
Dans le cadre du projet libre de fin d’année en NSI, je vous présente mon premier jeux vidéo en python fait à l’aide de pygame, une librairie spécialisé pour la création de jeux vidéo.
Librairie Pygame
Pygame est une bibliothèque de jeu open-source pour Python, qui permet de créer des jeux et des applications multimédias. Elle fournit des outils pour gérer les graphismes, le son, les entrées utilisateur, le réseau et plus encore.
Pygame utilise la bibliothèque SDL (Simple DirectMedia Layer) pour accéder aux fonctions du système d’exploitation, ce qui signifie que les jeux créés avec Pygame peuvent fonctionner sur de nombreuses plateformes, notamment Windows, macOS et Linux.
Pygame est une excellente option pour les débutants qui cherchent à créer des jeux simples (des base en programmation sont cependant nécessaire), mais il peut également être utilisé pour créer des jeux professionnels et des applications multimédias complexes.
Mon objectif sur ce projet a été de faire mes premiers pas avec la bibliothèque Pygame en Python. Cela a été un véritable défi qui m’aura fait découvrir de nombreuses mécaniques en Python, telles que le système de classe ou la programmation orientée objet, qui ont représenté pour moi un pas dans l’inconnu. Mon défi a donc été de créer un jeu simple pour débuter. Le but est de contrôler un personnage avec sa souris et d’éviter des briques qui apparaissent aléatoirement sur le côté de l’écran, tout cela en ayant le choix entre trois niveaux de difficulté différents.
Structure du Script
Pour la réalisation de mon jeu, j’ai décidé de me lancer un défi supplémentaire : l’utilisation de la Programmation Orientée Objet. Mais qu’est-ce que la Programmation Orientée Objet ?
La Programmation Orientée Objet est un paradigme de programmation qui permet de structurer un programme en utilisant des objets, qui sont des entités possédant des caractéristiques et des comportements spécifiques. Cette approche permet de modéliser des concepts du monde réel de manière plus naturelle et intuitive, en regroupant des fonctionnalités liées dans des classes, et en instanciant ces classes pour créer des objets.
En résumé, cela consiste à organiser son code de manière à ce qu’il soit ordonné à l’aide de classes contenant des fonctions et des constantes générales, ce qui conduit à un code plus lisible, plus maintenable et plus ordonné. Cependant, cela peut être relativement perturbant au début.
Voici un simple scripte sans utilisation de Programmation Orienté Objet qui permet de faire bougé une image nommé « ball.png » à l’aide des flèches directionnelles :
import pygame
pygame.init()
screen = pygame.display.set_mode((400, 400))
running = True
image = pygame.image.load("ball.png")
x = 0
y = 0
clock = pygame.time.Clock()
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
pressed = pygame.key.get_pressed()
if pressed[pygame.K_LEFT]:
x -= 1
if pressed[pygame.K_RIGHT]:
x += 1
if pressed[pygame.K_UP]:
y -= 1
if pressed[pygame.K_DOWN]:
y += 1
screen.fill((0, 0, 0))
screen.blit(image, (x, y))
pygame.display.flip()
clock.tick(60)
pygame.quit()
Le scripte est simple et efficace, pour autant si il venais à se complexifier cela deviendrait vite illisible. voici maintenant le même scripte avec l’utilisation de la Programmation Orienté Objet :
La particularité ici réside dans la clarté de chaque fonction et de leur utilité respective : « display » pour l’affichage, « handling_event » pour les interactions claviers-souris, « move » pour les mouvements du joueur… De plus, le programme est divisé en deux fichiers distincts : l’un pour le programme principal et l’autre pour le joueur. Ainsi, il est possible d’ajouter aisément de nouvelles fonctions pour des améliorations futures. Par exemple, la fonction « Update », actuellement inactive, pourrait être employée pour effectuer des vérifications, telles que les collisions.
Analyse du script
Passons maintenant à l’analyse du code.
Commençons par mon fichier « player.py », avec l’appel du module Pygame, la création de la classe et la fonction d’initialisation.
import pygame #On importe le module Pygame
class Player: #On crée la classe Player
# La fonction init est une fonction d'initialisation qui permet de déclarer toutes nos variables.
# Elle prend comme arguments self, qui est pris dans chaque fonction de la classe, x et y qui servent à définir la position initiale du joueur sur l'écran.
def init(self, x, y):
self.image = pygame.image.load("asset/Player.png")# On charge l'image du joueur
#Pour que vous puissiez être familiarisé avec le concept de rect, ce sont des rectangles que l'on ne voit pas, qui ont une taille que l'on leur définit et c'est grâce à ces rect, que l'on pourrait appeler hitbox, que l'on peut détecter des collisions.
self.rect = self.image.get_rect(center=(x, y))# On récupère le rectangle de l'image et on le centre en (x,y)
self.velocity = [0, 0]# On initialise la vitesse à 0 dans les deux directions
Une fois la mise en place de notre classe et de la fonction d’initialisation effectuée, nous créons la fonction de mouvement du joueur appelée « move », ainsi qu’une fonction « draw » qui permettra d’afficher notre personnage avec son rectangle.
def move(self, mouse_pos):# La fonction move permet de déplacer le joueur en fonction de la position de la souris, l'argument mouse_pos représente la position de la souris sur l'écran. Cette position est utilisée pour calculer la vitesse de déplacement du joueur, en soustrayant la position de la souris à la position actuelle du joueur.
# On calcule la différence entre la position de la souris et la position actuelle du joueur
self.velocity[0] = (mouse_pos[0] - self.rect.centerx)
self.velocity[1] = (mouse_pos[1] - self.rect.centery)
self.rect.move_ip(self.velocity)# On déplace le rectangle du joueur en fonction de la vitesse calculée
def draw(self, screen):# La fonction draw permet d'afficher le joueur sur l'écran
screen.blit(self.image, self.rect)# On blitte (st utilisée pour dessiner une surface sur une autre surface.) l'image du joueur sur le rectangle de celui-ci
Maintenait que je vous ai introduis mon fichier joueur passons au fichier jeu.
import pygame
import random
from player import Player
On importe les modules nécessaires au fonctionnement du jeu : Pygame pour gérer l’affichage graphique et l’interaction avec l’utilisateur, random pour générer des nombres aléatoires, et Player qui est une classe définie dans un fichier séparé et qui représente le joueur.
On définit la classe Game, qui représente le jeu en lui-même. Son constructeur prend en paramètre l’objet screen qui représente la surface sur laquelle le jeu sera affiché.
On initialise différentes variables, comme self.running qui permet de savoir si le jeu est en cours d’exécution ou non, self.player qui représente le joueur, self.background qui est l’image de fond, self.brique qui est l’image représentant les obstacles à éviter, et plusieurs variables liées à ces obstacles (self.brique_positions, self.brique_speed, self.brique_spawn_rate, self.brique_spawn_counter, self.brique_spawn_augmentation, self.brique_spawn_increase_counter).
On définit également self.total_time et self.total_time_max pour gérer le temps de jeu, et self.difficulté qui est utilisé pour régler la difficulté du jeu en fonction de la réponse de l’utilisateur à une question posée par input.
Enfin, on masque le curseur de la souris avec pygame.mouse.set_visible(False).
def gestion_events(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.running = False
self.player.move(pygame.mouse.get_pos())
La méthode gestion_events permet de gérer les événements liés à l’interaction de l’utilisateur avec la fenêtre Pygame.
Le code utilise une boucle for pour récupérer chaque événement dans la liste des événements de Pygame. Si l’un des événements est de type QUIT, cela signifie que l’utilisateur a cliqué sur le bouton de fermeture de la fenêtre. Dans ce cas, la variable self.running est définie sur False, ce qui interrompt la boucle de jeu.
La méthode appelle également la méthode move de l’objet Player pour mettre à jour sa position en fonction de la position de la souris de l’utilisateur.
def adaptative_brique_rects(self):
self.brique_rects = []
for pos in self.brique_positions:
rect = pygame.Rect(pos[0], pos[1], self.brique.get_width(), self.brique.get_height())
self.brique_rects.append(rect)
La méthode adaptative_brique_rects est appelée pour mettre à jour les rects de collision des briques en fonction de leurs nouvelles positions.
def spawn_brique(self):
y = random.randint(0, self.screen.get_height() - self.brique.get_height())
self.brique_positions.append((-self.brique.get_width(), y))
La méthode spawn_brique est appelée pour générer une nouvelle brique à une position aléatoire sur l’axe y et avec une position initiale en dehors de la fenêtre sur l’axe x.
def move_briques(self):
for i in range(len(self.brique_positions)):
pos = list(self.brique_positions[i])
pos[0] += self.brique_speed
self.brique_positions[i] = tuple(pos)
self.adaptative_brique_rects()
La méthode move_briques met à jour la position des briques en ajoutant la valeur de self.brique_speed à la coordonnée x de chaque position dans self.brique_positions.
def update(self):
# Incrémenter le compteur de temps de spawn des briques par la difficulté du jeu
self.brique_spawn_counter += self.difficulté
# Augmenter la vitesse des briques si le compteur de spawn des briques est un multiple de 120
if self.brique_spawn_counter % 120 == 0:
self.brique_speed += 0.2
# Vérifier si le compteur d'augmentation de spawn des briques a atteint sa limite
self.brique_spawn_increase_counter += 1
if self.brique_spawn_increase_counter >= self.brique_spawn_augmentation * 60:
self.brique_spawn_increase_counter = 0
self.brique_spawn_rate -= 10
# Ajouter une nouvelle brique à la liste des positions de briques si le compteur de spawn des briques a atteint le taux de spawn des briques
if self.brique_spawn_counter >= self.brique_spawn_rate:
self.brique_spawn_counter = 0
self.spawn_brique()
# Déplacer toutes les briques dans la direction de la vitesse actuelle des briques
self.move_briques()
# Incrémenter le temps total de jeu de 1
self.total_time += 1
# Vérifier si le joueur a perdu en entrant en collision avec une brique
for rect in self.brique_rects:
if rect.colliderect(self.player.rect):
print("_____________________________________________________________________________\n")
print(" Vous avez perdu, Votre temps est de", self.total_time/100, "secondes, bien joué à vous ;)")
print("_____________________________________________________________________________\n")
self.running = False
break
else:
pass
La méthode update est appelée à chaque boucle de jeu pour mettre à jour les positions des briques, vérifier si le joueur a perdu en entrant en collision avec une brique et pour augmenter la difficulté du jeu.
Elle commence par incrémenter le compteur de temps de spawn des briques par la difficulté du jeu, pour que les briques apparaissent plus rapidement avec des niveaux de difficulté plus élevés.
Ensuite, si le compteur de spawn des briques est un multiple de 120, la vitesse de déplacement des briques est augmentée de 0,2.
La méthode vérifie également si le compteur d’augmentation de spawn des briques a atteint sa limite, qui est définie par self.brique_spawn_augmentation * 60. Si c’est le cas, le compteur est réinitialisé et le taux de spawn des briques est diminué de 10.
Si le compteur de spawn des briques atteint le taux de spawn des briques défini par self.brique_spawn_rate, la méthode spawn_brique est appelée pour ajouter une nouvelle brique à la liste des positions de briques.
La méthode move_briques est ensuite appelée pour déplacer toutes les briques dans la direction de la vitesse actuelle des briques.
Le temps total de jeu est ensuite incrémenté de 1.
Enfin, pour chaque rect de brique dans la liste self.brique_rects, la méthode vérifie s’il y a une collision avec le rectangle de la zone de collision du joueur. Si c’est le cas, la méthode affiche le message de fin de jeu et met la variable self.running à False pour arrêter la boucle de jeu.
def display(self):
# Afficher le fond d'écran
self.screen.blit(self.background, (-200, -350))
# Parcourir toutes les positions des briques et les afficher
for pos in self.brique_positions:
self.screen.blit(self.brique, pos)
# Afficher le joueur
self.player.draw(self.screen)
# Mettre à jour l'affichage
pygame.display.flip()
La méthode display(self) affiche les éléments du jeu sur l’écran. Elle utilise la méthode blit pour afficher le fond d’écran, chaque brique de la liste brique_positions et le joueur (player) sur l’écran. Ensuite, elle appelle la méthode flip de la classe pygame.display pour mettre à jour l’affichage.
def run(self):
# Boucle principale du jeu
while self.running:
# Gérer les événements (ex: appuyer sur une touche, quitter le jeu)
self.gestion_events()
# Mettre à jour le jeu (ex: déplacer les briques, vérifier les collisions)
self.update()
# Afficher le jeu
self.display()
# Limiter le nombre de frames par seconde à 60
self.clock.tick(60)
# Réafficher la souris et quitter Pygame
pygame.mouse.set_visible(True)
pygame.quit()
La méthode run(self) contient la boucle principale du jeu. Elle s’exécute tant que l’attribut running est vrai. À chaque itération de la boucle, elle gère les événements (appel à gestion_events()), met à jour les éléments du jeu (appel à update()), affiche le contenu du jeu sur l’écran (appel à display()) et attend un certain temps défini par la méthode tick de pygame.time.Clock. Enfin, elle quitte le jeu (pygame.quit()) lorsque la boucle est terminée.
# Initialiser Pygame
pygame.init()
# Créer une fenêtre de jeu
screen = pygame.display.set_mode((1080, 720))
# Créer une instance de la classe Game en lui passant la fenêtre de jeu en argument
game = Game(screen)
# Lancer le jeu
game.run()
# Quitter Pygame
pygame.quit()
La partie en dehors de la classe initialise la bibliothèque Pygame (pygame.init()) et crée une fenêtre de jeu (pygame.display.set_mode((1080, 720))). Ensuite, elle crée une instance de la classe Game avec l’écran en tant qu’argument et appelle la méthode run de l’instance pour démarrer le jeu. Enfin, elle quitte la bibliothèque Pygame (pygame.quit()) après la fin du jeu.
En conclusion, ce projet est un petit jeu simple mais amusant, il est sur l’univers de Mario. Si vous voulez essayer ce jeu par vous-même, vous pouvez le télécharger en cliquant sur le lien ci-dessous. Pour lancer le jeu, assurez-vous d’écrire le niveau de difficulté souhaité (1, 2 ou 3) dans la console Python. Si vous ne le faites pas, la fenêtre restera noire et le jeu ne se lancera pas. On commande le personnage avec sa souris.
Qu’il s’agisse d’une dissertation, d’un e-mail ou d’une lettre de motivation, taper nos textes est devenu une norme de notre ère. Et cette tendance n’est pas insensée : pouvoir écrire ses mots avec une calligraphie, espacement et centrage parfaits représente un gain de temps indéniable ! Seulement, ce nouveau moyen de rédiger vient avec son lot de règles à respecter. Jetez un coup d’œil à ce tutoriel, et vous saurez tout ce que vous devez connaître afin de maîtriser la mise en page de votre texte !
Bande annonce 😉
Avant-propos
Tout au long de ce tutoriel, le nom « espace » sera utilisé au féminin. Par exemple, il pourrait être dit :
« Il faut une espace avant et après ce signe de ponctuation. »
Cela n’est pas une erreur ! Le nom « espace », lorsqu’il désigne une étendue, une capacité ou simplement notre cosmos, est bel est bien masculin ; en revanche, lorsqu’il désigne un blanc qui sépare deux mots, il est féminin. Selon certains, il s’agirait d’un archaïsme datant de l’ancien et moyen français, et selon d’autres, cela ferait référence aux lamelles utilisées jadis en imprimerie.
Bref. Par souci de purisme, j’utiliserai « espace » au féminin.
Introduction
La typographie est l’art et la technique de l’arrangement des lettres, des chiffres et des symboles dans un texte. Elle consiste à ajuster la mise en page, les polices de caractères, les tailles, les couleurs et les espacements afin de rendre un texte tapé lisible, clair, esthétique et, par-dessus tout, crédible.
Elle est utilisée dans de nombreux domaines telle la publication, la publicité, l’emballage, la signalétique et le design web.
Bien que les règles soient nombreuses, il n’empêche qu’en apprendre les bases vous aidera à produire des écrits qui vaudront d’être lus. Peut-être vous considérez-vous déjà familier avec ce sujet ; néanmoins, il réside toujours des subtilités qu’il serait intéressant de connaître.
Toutefois, tout logiciel de traitement de texte, tel Word, possède un correcteur automatique. Celui-ci non seulement régule les fautes d’orthographe, de conjugaison et de grammaire, mais indique toute erreur d’espacement. Dans ce cas, à quoi sert-il d’apprendre la typographie ? Je vous donnerai trois raisons :
1. Comprendre la logique derrière tout domaine permet d’affiner son esprit et améliorer sa culture générale. La typographie est une compétence qui peut être captivante, et en saisir le fonctionnement vous aidera toujours dans votre vie ;
2. Les correcteurs automatiques ne sont pas nécessairement justes : il advient toujours qu’une erreur ou deux ne soient pas remarquées par le correcteur ; ou, pire, que celui-ci propose une correction erronée. Dans le cas d’une opposition (cf. Les oppositions), il ne parviendra même pas à se décider ! Apprendre les bases vous permettra de ne pas tomber dans le panneau ;
3. Il arrivera qu’aucun correcteur automatique ne soit là pour confirmer vos phrases. Par exemple, lorsque vous rédigez un e-mail sur Gmail ou si vous tapez un texte sur Google doc, il ne vous est pas fourni de correcteur typographique. Si vous désirez faire bonne impression sans perdre le temps de copier/coller votre écrit dans un logiciel de traitement de texte, il vous faudra connaître ces règles.
En un mot, ce tutoriel vous enseignera la manière de placer correctement des espaces dans vos phrases. En effet, faut-il placer une espace avant un point d’exclamation ? Faut-il insérer des espaces à l’intérieur de guillemets ? Comment faut-il s’y prendre avec un texte en anglais ? Trouvez les réponses ci-après !
Les différents types d’espaces
Avant toute chose, considérons les différents types d’espaces en typographie. Nous avons :
L’espace justifiante
L’espace insécable
L’espace fine
L’espace justifiante est l’espace que l’on utilise le plus fréquemment et qui est tapée grâce à la barre d’espace sur un clavier. Elle est nommée ainsi car sa taille est ajustable si le texte est justifié.
Une espace insécable est une espace qui ne peut être séparée des deux mots qui l’entourent par un retour à la ligne. Autrement dit, ce type d’espace garde les deux mots sur la même ligne.
Une espace fine est une espace deux fois plus étroite que l’espace justifiante. Elle est considérée insécable dans la majorité des cas.
Nous allons utiliser ces trois types d’espaces tout au long de ce tutoriel.
Les signes de ponctuation simples
Les signes de ponctuation simples sont constitués d’un seul élément. Ils sont au nombre de trois :
La virgule (,)
Le point (.)
Les points de suspension (…)
(Les points de suspension étant composés de points, ils font partie des signes de ponctuation simple.)
Pour ces signes, il ne faut pas mettre d’espace avant, mais en placer une après.
À faire :
Lundi matin,_le professeur de NSI entra dans la salle de classe en furie._Il avait sous le bras les contrôles de la semaine précédente…_
À ne pas faire :
Lundi matin_,le professeur de NSI entra dans la salle de classe en furie_.Il avait sous le bras les contrôles de la semaine précédente_…
Remarque : Lorsque la virgule sert à écrire un nombre décimal, elle ne nécessite pas d’espace après. On écrira donc « 42,666 ». Cela vaudrait de même pour un point qui séparerait un nombre en groupe de trois chiffres, comme dans « 120.000 » s’il n’était pas recommandé de mettre une espace insécable à la place, et de taper « 120000 ».
Les signes de ponctuation complexes
Les signes de ponctuation complexes comportent deux éléments. Il en existe quatre :
Le point d’exclamation (!)
Le point d’interrogation (?)
Le double point (:)
Le point-virgule (;)
Il faut placer une espace avant et après ces signes.
À faire :
La mauvaise nouvelle fut vite annoncée_:_pas un élève avait eu au-dessus de la moyenne_!_Comment de tels résultats avaient-ils pu être possibles_?_
À ne pas faire :
La mauvaise nouvelle fut vite annoncée:_pas un élève avait eu au-dessus de la moyenne!_Comment de tels résultats avaient-ils pu être possibles?_
Remarque 1 : L’espace placée devant un signe de ponctuation complexe doit être insécable. Elle peut être fine ou non. Word crée automatiquement une espace insécable lorsque vous tapez ces signes de ponctuation.
Remarque 2 : Si vous désirez placer un point d’interrogation à côté d’un point d’exclamation afin d’exprimer du décontenancement, il ne faut pas mettre d’espace entre les deux. La règle de l’espace avant et après s’applique au groupement. On écrira donc : « Qu’est-ce que c’est que ça_?!_»
L’apostrophe
L’apostrophe (‘), qu’elle soit droite ou courbe, n’a aucune espace de part et d’autre. En d’autres termes, elle est collée aux deux mots qui l’entourent.
À faire :
D'habitude, si quelqu'un se retrouvait avec une note médiocre, le professeur s'avérait bien plus compréhensif. Cette fois-ci, ce n'était pas le cas.
À ne pas faire :
D_'_habitude, si quelqu_'_un se retrouvait avec une note médiocre, le professeur s_'_avérait bien plus compréhensif. Cette fois-ci, ce n_'_était pas le cas.
Les tirets
Nous allons considérer trois types de tirets :
Le tiret court ou trait d’union (–)
Le tiret moyen/demi-cadratin (–)
Le tiret long/cadratin (—)
Le tiret court ou trait d’union est utilisé pour les mots composés ainsi que les coupures. Il ne possède pas d’espace avant ni après.
Le tiret moyen ou demi-cadratin permet d’insérer des commentaires. Celui-ci est entouré par deux espaces.
Le tiret long ou cadratin est utile pour les dialogues. Afin de s’en servir, il faut aller à la ligne et le coller au bord gauche de la page. Il a une espace derrière lui.
À faire :
—_Donnez-moi une seule raison_–_car je n’en trouve pas une_–_de ne pas tous vous punir ! s’exclama-t-il.
À ne pas faire :
—Donnez_-_moi une seule raison–car je n’en trouve pas une–de ne pas tous vous punir ! s’exclama_-_t_-_il.
Remarque : Il faut placer deux espaces insécables à l’intérieur des tirets moyens lorsque ceux-ci insèrent un commentaire. Autrement dit, il faut une espace insécable à droite du premier tiret et une à gauche du second. Ces espaces peuvent être fines ou non.
Les parenthèses
Dans la famille des parenthèses, il y a :
Les parenthèses (())
Les crochets ([])
Les accolades ({})
Ces signes nécessitent une espace à l’extérieur mais aucune à l’intérieur. Il faut donc uniquement placer une espace à gauche de la parenthèse ouvrante et à droite de la parenthèse fermante.
À faire :
Les élèves honteux_(ils avaient promis de réviser)_ne surent quoi répondre.
À ne pas faire :
Les élèves honteux(_ils avaient promis de réviser_)ne surent quoi répondre.
Les guillemets
En français, il est possible d’utiliser ces trois types de guillemets :
Les guillemets français (« »)
Les guillemets anglais (” ”)
Les apostrophes (‘ ‘)
Les guillemets français sont utilisés pour insérer une citation, introduire un discours direct, encadrer une expression inhabituelle ou souligner le sens spécial d’un mot. Ceux-ci ont une espace à l’extérieur et à l’intérieur.
Les guillemets anglais sont surtout utilisés pour les doubles citations, c’est-à-dire des citations à l’intérieur d’une citation. Ils possèdent une espace à l’extérieur, mais non à l’intérieur.
Les apostrophes, bien que rares, sont utilisées pour les triples citations. Elles suivent la même règle que les guillemets anglais.
À faire :
En effet, leurs résultats étaient_«_absolument_"incroyables"_»_selon le ton ironique de leur professeur.
À ne pas faire :
En effet, leurs résultats étaient«absolument"_incroyables_"»selon le ton ironique de leur professeur.
Remarque : Les guillemets français nécessitent une espace insécable à l’intérieur. Il faut donc placer une espace insécable à droite du guillemet ouvrant et à gauche du guillemet fermant. Word ne crée pas ces espaces automatiquement.
La barre oblique
La barre oblique, ou le slash, sert à indiquer un choix entre plusieurs expressions, écrire une abréviation ou faire une fraction.
Ce signe de ponctuation est relativement jeune. De ce fait, les règles de typographie à son sujet ne sont pas gravées dans le marbre.
La plupart du temps, la barre oblique ne possède pas d’espaces de part et d’autre. Toutefois, lorsqu’elle sépare deux expressions composées de plus d’un mot, il est considéré comme judicieux de placer une espace à sa gauche et à sa droite.
L’important est de faire attention à l’uniformité du texte. En effet, placer une barre oblique entourée d’espaces juste à côté d’une sans espaces est à éviter. Il est intéressant alors de choisir l’une de ces deux règles pour l’entièreté d’un document.
À faire :
Ce dernier à présent pouvait punir tous ses élèves et/ou les jeter par la fenêtre.
À ne pas faire :
Ce dernier à présent pouvait punir tous ses élèves et_/_ou les jeter par la fenêtre.
Remarque : Lorsqu’une barre oblique délimite deux expressions qui contiennent plus d’un mot, cette barre oblique doit être entourée d’espaces insécables.
Les symboles arithmétiques
Les symboles arithmétiques sont nombreux et varient des plus connus (+ – ×÷ =) aux plus cryptiques. Leur règle est simple : il faut placer une espace de chaque côté du signe.
À faire :
Au lieu de cela, il s'empara de la première copie de sa pile de contrôles et lu : « 5_+_7_×_4_=_48 ».
À ne pas faire :
Au lieu de cela, il s'empara de la première copie de sa pile de contrôles et lu : « 5+7×4=48 ».
Les unités de mesure
Les unités de mesures sont de même nombreuses. Les plus fréquemment utilisées au quotidien peuvent être le gramme (g), le mètre (m), le litre (L), la seconde (s), l’euro (€) et le degré Celsius (°C). Ces symboles sont toujours précédés et suivis d’une espace.
À faire :
Il s'arrêta 1_s_et recula d'1_m_en silence.
À ne pas faire :
Il s'arrêta 1s_et recula d'1m_en silence.
Remarque : Il est nécessaire de placer une espace insécable entre le nombre et son unité de mesure.
Les oppositions
Il peut arriver que les règles de typographie se contredisent et créent des oppositions. En effet, imaginez que vous souhaitiez placer un point après avoir fermé une parenthèse. Faut-il placer une espace entre les deux ? D’un côté, oui car la parenthèse possède une espace à l’extérieur ; mais d’un autre côté, non car le point est forcément collé au signe qui le précède. Et en ce qui concerne une apostrophe suivit de guillemets français ? L’apostrophe nous indique qu’il ne faut pas mettre d’espace entre les deux signes, mais les guillemets en requièrent une !
Lorsque vous vous retrouvez face à ce genre de paradoxes, le mieux à faire est de ne pas mettre d’espace, quand bien même cela va à l’encontre de quelque règle de typographie.
À faire :
Les élèves comprirent que l'« ardeur » de leur professeur avait pris fin (sans vraie raison).
À ne pas faire :
Les élèves comprirent que l'_« ardeur » de leur professeur avait pris fin (sans vraie raison)_.
Et en anglais ?
Les règles exposées tout au long de ce tutoriel représentent les règles françaises de typographie. En d’autres termes, chaque langage possède ses propres lois d’espacement. Cette section vise à montrer les différences qui existent en typographie entre le français et l’anglais. J’ai choisi cette langue car elle est fréquemment utilisée sur Internet.
Le point et la virguleéchangent de rôle dans les mathématiques anglaises. On écrira donc un nombre décimal avec un point, et tout nombre supérieur à 1 000 comportera des virgules tous les trois chiffres. Par exemple, on tapera en anglais : « 42,333.12 ». La règle reste toutefois inchangée : pas d’espace avant ni après.
Les signes de ponctuation complexes (: ; ! ?) ne sont pas précédés d’une espace. Autrement dit, ils sont collés au mot qui les précède.
Les guillemets français ne sont pas utilisés. Ainsi, dans un texte anglais seront uniquement tapés les guillemets anglais et les apostrophes, qui suivent les mêmes règles qu’en français.
En anglais, les dialogues ne se forment pas à partir de tirets cadratins, mais simplement de guillemets anglais mis à la ligne.
Les devises, c’est-à-dire la monnaie utilisée comme l’euro (€), le dollar ($), la livre sterling (£), etc., est placée devant le nombre et n’a pas d’espace après. On écrira donc, par exemple, « €10 » pour dix euros.
Hormis ces points, les règles anglaises et françaises sont similaires.
Un exemple de bonne typographie
Voici deux textes qui possèdent les mêmes mots mis côte à côte. Le premier suit les règles d’espacement en typographie, le second non.
De nos jours retenir tous nos mots de passe devient de plus en plus compliqué tout comme les sécuriser lorsqu’on les a enregistrés afin d’éviter qu’ils ne soient volés. Pour cela, je vous propose un tutoriel pour retrouver ces mots de passe sur Firefox ,Google Chrome ou Edge et les protéger en limitant les risques de vols et d’usurpation d’identité.
Retrouver ses mots de passe sur Firefox
Sur votre ordinateur, ouvrez Firefox puis cliquez sur le menu en haut à droite représenté par trois barres horizontales
Allez sur Mots de passe afin d’accéder à tous les mots de passe enregistrés
Maintenant que vous y êtes, vous avez à votre gauche les sites et identifiants enregistrés et vous avez la possibilité d’accéder aux mots de passe et adresses des sites. Pour accéder à votre mot de passe, il suffit seulement de cliquer sur l’oeil
Retrouver ses mots de passe sur Google Chrome
Comme sur Firefox, ouvrez l’onglet chrome et accéder au menu représenté par trois points en haut à droite
Par la suite allez dans Paramètre
Après y avoir accédé, dirigez-vous vers la section Saisie automatique et cliquez sur Gestionnaire de mots de passe
Vous pouvez maintenant accéder à vos identifiants et mots de passe déjà enregistrés dans Chrome en cliquant sur l’oeil
Attention, contrairement à Firefox, Google Chrome possède une sécurité qui avant d’afficher le mot de passe vous demande votre identifiant et votre code d’ordinateur
Retrouver ses mots de passe dans Edge
Enfin nous passons au dernier site afin de retrouver les mots de passe enregistré Miscrosoft Edge!
Comme les deux autres, il faut se rendre sur le menu représenté par 3 petits points
Vous recherchez comme dans Google Chrome la rubrique Paramètres
Une nouvelle page s’ouvre. Il vous faut sélectionner Profils puis dans la partie centrale Mots de passe
Vous pouvez maintenant accéder aux sites Web avec pour chacun un identifiant, un mot de passe et l’intégrité de celui-ci (permet d’évaluer sa vulnérabilité)
Enfin, pour afficher votre mot de passe il vous suffira d’appuyer sur l’icône en forme d’oeil où par la suite une fenêtre s’affichera en vous demandant votre identifiant et votre mot de passe de votre ordinateur comme cela se passe pour Google chrome
Protéger ses mots de passe sur Firefox
Comme on a pu le remarquer, Google Chrome et Microsoft Edge possède déjà une protection de mots de passe lorsque l’on clique sur l’oeil afin de limiter le vol de mots de passe et l’usurpation d’identité. Firefox quant à lui ne possède pas cela directements mais permet tout de même de protéger les mots de passe.
Comme pour récupérer un mot de passe, vous devez refaire l’étape:
accéder au menu
Après cela, ne sélectionnez pas Mots de passe mais Paramètres
Une fois que vous êtes sur la page, dans le menu de gauche, cliquez sur Vie privée et sécurité puis faites défiler avec votre souri pour arriver à la section Identifiant et mots de passe. Une fois là il vous suffit de sélectionner Utiliser un mot de passe principal
Vous devrez par la suite définir un mot de passe de base (principal) afin d’accéder et de protéger ensuite les mots de passe spécifiques enregistrés que vous validerez par OK
Une fois cela réalisé vous pouvez le tester
accédez au menu
cliquez sur mot de passe
et normalement, Firefox vous créera une fenêtre qui vous demandera votre mot de passe principal afin d’accéder à ceux que vous voulez
Que vous souhaitiez monter une interview, mixer vos réalisations musicales, ajouter une ambiance sonore à un récit ou même créer votre propre sonnerie de téléphone, vous serez amené à utiliser un logiciel de montage audio. Il en existe de très nombreux, payants ou gratuits, avec plus ou moins de fonctionnalités. Le logiciel Audacity que je vais utiliser et vous présenter à travers ce tutoriel est un des outils de montage le plus utilisé car il regroupe de nombreuses qualités : c’est un logiciel gratuit, disponible sur tous les systèmes d’exploitation (Windows, Mac OS, Linux) qui est à la fois simple d’accès et très complet ce qui en fait un outils prisé par les professionnels.
Plutôt que de faire une présentation d’Audacity au travers de toutes ses fonctionnalités ce qui donnerait lieu à un tutoriel aussi long que fastidieux au vu de la richesse du logiciel, j’ai préféré vous présenter les principales fonctionnalités à travers une mise en situation : je vais vous montrer comment réaliser un podcast simple, constitué d’une introduction musicale suivie du contenu du podcast, de la voix qui aura été au préalable enregistrée à l’aide d’Audacity, et qui se conclura par un autre morceau musical.
1. Présentation rapide de l’interface d’Audacity
Voici comment se présente l’interface graphique d’Audacity :
Cette interface se divise en trois parties :
un menu constitué des différents onglets donnant accès aux nombreuses fonctionnalités du logiciel par des menus déroulants
les barres d’outils (partie encadrée en bleu)
le plan de travail ou s’affichent les différentes pistes audio nécessaires au projet (partie encadrée en rouge).
Parmi les nombreuses barres d’outils détaillées ci-dessous, il y a :
en rouge : le lecteur avec les commandes classiques de lecture, pause, enregistrement,…
en jaune : la selection du nombre de canaux : 1=mono, 2=stéréo. Il est possible de choisir jusqu’à 32 canaux différents pour une même piste
en bleu : la barre des commandes de bases telles que « couper », « copier », « coller », « effacer », fonctions de zoom
en vert : la boite à outils qui regroupe les outils de sélection (pour sélectionner une portion de la piste), l’outil de retouche, l’outil d’enveloppe sur lequel je reviendrai plus tard
en mauve : le variateur de vitesse de lecture
les vu-mètres qui montrent (barres horizontales vertes) le niveau des signaux audio d’entrée/sortie
le réglage des niveaux sonores d’entrée/sortie (au-dessus du cadre bleu)
Enfin le plan de travail est constitué des différentes pistes audio nécessaires au projet. Voici à quoi ressemble une piste audio (mono).
La piste est elle même divisée en deux parties :
une large fenêtre dans laquelle apparaît la courbe (en bleu) du signal sonore (il y a autant de courbes que de canaux)
à droite de ce signal, une fenêtre regroupant des informations sur ce signal telles que le nombre de canaux, la fréquence d’échantillonnage (44,1 kHz par défaut ce qui correspond à un signal HiFi), des curseurs permettant de régler le niveau sonore et la balance entre la droite et la gauche c’est-à-dire la répartition entre la sortie droite et la sortie gauche (même si le signal est mono) et des options permettant de rendre la piste muette (« silencer ») ou au contraire de rendre toutes les autres muettes (« solo ») lors de la lecture simultanée de plusieurs pistes.
2. Enregistrement d’une voix avec Audacity
Audacity permet d’enregistrer un signal sonore en mono ou en stéréo. La stéréo est utile lorsque le champ sonore à capter est large, en pleine nature, ou que l’on souhaite capturer l’ambiance d’une salle en même temps que le spectacle qui s’y déroule. Dans le cas de la captation d’une simple voix (mon cas ici) un enregistrement en mono est suffisant. Il faut savoir que lors de l’exportation du projet finalisé celui-ci sera de toute façon automatiquement converti en stéréo. Pour procéder à l’enregistrement rien de plus simple :
on sélectionne le nombre de canaux enregistrement (mono/stéréo) : mono dans mon cas
on clique sur la touche d’enregistrement (le bouton avec un point rouge)
une fois l’enregistrement terminé on clique sur la touche d’arrêt (le bouton avec un carré noir).
Nous obtenons la piste suivante d’une durée d’environ 34 secondes :
a. « Silencer » le début de l’enregistrement
Avant d’utiliser cet enregistrement en l’état, il faut procéder à quelle retouches dans le but d’en améliorer la qualité et de corriger d’éventuelles erreurs de diction.
Pour commencer zoomons sur le début du signal. Pour cela, il suffit de placer le curseur dans la zone que l’on souhaite agrandir (ici à 2 sec.) et de cliquer ce qui fera apparaître un trait noir vertical traversant la piste. En cliquant sur l’icone « zoom avant », le zoom (horizontal) s’effectuera autour de cette zone.
On voit que durant les deux premières secondes bien qu’elles correspondent à du silence, la courbe n’est pas parfaitement plate et que donc un léger bruit de fond subsiste. Cela est d’autant plus visible si l’on effectue un zoom vertical. Pour cela, il suffit de placer le curseur de la souris au niveau du 0.0 à droite de la piste audio. Celui-ci se transformera en loupe et en jouant sur la molette de la souris on pourra zoomer et dézoomer à volonté.
On voit clairement que la portion du signal située au dessus de la flèche verte est bruitée. Nous allons donc la remplacer par du silence. Cette opération se fait en deux temps. Tout d’abord, il faut sélectionner la partie à transformer. Pour cela, on positionne le curseur au début de la portion, puis on clique (pour tout le tutoriel « cliquer = cliquer sur le bouton droit ») et en maintenant le bouton appuyé, on sélectionne en se déplaçant vers la droite le morceau qui nous intéresse qui va alors prendre une teinte bleu clair. Pour terminer la sélection, il suffit de relâcher le clic de la souris. La deuxième étape consiste alors à cliquer sur l’icône « silencer » (encadré ci-dessous) pour transformer la sélection en silence comme on peut le constater sur les deux captures suivantes.
ce qui nous donne, après avoir utiliser la commande « silencer la sélection » (encadrée en rouge) la piste ci-dessous :
b. Corriger une erreur de diction
Lors de cet enregistrement, j’ai (volontairement) commis une erreur de diction en me trompant sur un mot , erreur que j’ai corrigée aussitôt en reprenant correctement cette fois le mot et en poursuivant ma lecture. Il est d’ailleurs conseillé lorsqu’on commet une erreur de ce type de se corriger et de continuer son enregistrement plutôt que de tout arrêter et tout reprendre à zéro ce qui peut être une source de stress d’autant plus importante que l’enregistrement est long. Audacity est un logiciel qui permet de rectifier après coup assez facilement ce type d’erreur comme nous allons le voir.
La première étape consiste à repérer la portion du signal dans laquelle se situe l’erreur. Pour cela, après une première écoute qui va nous permettre de repérer assez vaguement le passage en question, on va pouvoir sélectionner dans la réglette temporelle (barre graduée légèrement bleutée située juste au dessus de la piste) une fenêtre en procédant de la même manière que lorsqu’on a sélectionné un morceau de la piste sauf que cette fois-ci, il faut placer le curseur sur cette réglette. Une fois la fenêtre temporelle sélectionnée, celle-ci sera relue en boucle (il ne sera plus nécessaire de réécouter à chaque fois toute la piste. Ainsi en ajustant les bord de cette fenêtre temporelle, il devient facile d’isoler avec précision le passage qui nous intéresse (partie de la piste encadrée en rouge ci-dessous. Le flèche rouge indique la fenêtre temporelle correspondante.)
Pour supprimer ce passage, il faut commencer par le sélectionner mais il faut éviter d’effectuer un simple « couper » ou un « supprimer et raccorder » car au niveau du raccord il subsistera un petit bruit (il y a peu de chance que le raccord se fasse parfaitement et soit inaudible). Pour cela quelques manipulations sont nécessaires. Dans un premier temps, il faut lancer la commande « supprimer-séparer »
ce qui va avoir pour effet de supprimer le morceau désiré et de créer un espace vide à la place et de couper la piste en deux parties (on parle aussi de clips) distinctes.
L’étape suivante consiste à rapprocher les deux clips sans pour autant les coller. Pour cela, on va déplacer le clip de droite vers la gauche. Ce déplacement temporel aussi appelé ajustement temporel est une opération très commune et très simple qu’il est essentiel de maîtriser. Il suffit de placer le curseur sur la partie supérieur de la piste (zone plus claire que le reste de la piste) ; celui-ci prend alors la forme d’une main qui permet d’un simple double-clic de la souris de saisir la piste et de la déplacer horizontalement à sa guise . Dans notre cas, nous allons faire glisser cette piste pour la placer à 0,2 sec de la piste gauche. Pour les opérations suivantes, il peut-être nécessaire d’effectuer un zoom horizontal (x2 suffit) autour de la fin du clip de gauche et du début du clip de droite afin d’avoir plus de détails et ainsi d’être plus précis dans nos futures manipulations. Pour rendre la transition entre les deux morceaux parfaitement inaudible, on va sélectionner un cours laps de temps (quelques dixièmes de seconde) avant la fin de la piste de gauche puis réaliser un « fondu en fermeture » comme indiqué ci-dessous.
Puis de la même manière, on selectionne un cours pas de temps au début de la piste de droite et on réalise un « fondu en ouverture » :
Le but du fondu en fermeture c’est de diminuer la signal sonore jusqu’au silence (l’inverse pour le fondu en ouverture). Par ces quelques manipulations, nous avons supprimé notre erreur et récupéré une piste audio sans raccord audible.
c. Supprimer le bruit de fond
Un autre problème récurrent lors d’un enregistrement est qui peut entâcher la qualité du signal sonore est la présence de bruit de fond. Celui-ci peut avoir plusieurs origines (qui peuvent s’additionner) : matériel de captation de mauvaise qualité ou défectueux, bruit environnant comme le ventilateur du PC. Ce bruit, même léger, peut-être gênant et altérer la qualité de l’enregistrement surtout pendant les périodes de silence ou il sera le plus perceptible. Heureusement Audacity dispose d’une commande qui permet de réduire significativement ce bruit. La tâche est assez simple. Tout d’abord il faut sélectionner un morceau de la piste ne contenant que ce bruit de fond, c’est à dire une partie « silencieuse » (1 ou 2 sec. suffisent).
Ensuite, il faut cliquer sur l’onglet « Effets » puis dans le menu déroulant sélectionner « réduction de bruit ». La fenêtre suivante s’ouvrira :
cliquer alors sur « Prendre le profil du bruit » ce qui permettra à Audacity de savoir ce qu’il devra supprimer.
Retourner ensuite sur la piste et sélectionner cette fois-ci la totalité de la piste (placer le curseur à l’intérieur de la piste de double-cliquer : la totalité de la piste sera colorée en bleu ciel) puis recommencer l’opération précédente : Effets>Réduction de bruit et la fenêtre précédente s’ouvrira à nouveau. Cette fois-ci il faudra cliquer sur le bouton valider :
La totalité de la piste a été débruitée : même s’il n’a pas complètement disparu, le bruit a été significativement réduit comme on peut le constater sur le signal sonore ci-dessous que l’on peut comparer avec celui avant débruitage affiché plus haut.
3. Mixage de la musique d’introduction et du début du podcast
La plupart de podcasteurs débutent leur création par une brève introduction musicale (aussi appelée « jingle ») qui est en quelque sorte la signature du podcasteur. Pour ne pas déroger à la règle, nous allons ajouter en début de notre enregistrement vocal effectué précédemment, un jingle. La première étape va consister à importer un fichier musical (pour cette illustration, j’ai utilisé une musique libre droit).
a. Importation de la musique d’introduction
Le format du fichier importe peu car Audacity reconnait la plupart des formats audio. L’importation est une opération très simple qui s’effectue en quelques clics de souris comme le montre la capture ci-dessous :
Une fenêtre s’ouvre sur le répertoire dans lequel se trouve le fichier que l’on souhaite importer, dans mon cas le fichier Moon-Wisper.mp3
Une nouvelle piste constituée de deux sous-pistes (car le fichier importé est en stéréo) apparaît sous la piste de notre enregistrement : elle correspond à notre fichier musical.
Il est important de noter qu’il n’y a pas de différence à travailler sur une piste mono ou stéréo puisqu’en stéréo toute opération effectuée sur une des deux sous-pistes se répercutera automatiquement et de manière identique sur l’autre sous-piste.
b. Différentes stratégies de mixage
En présence de plusieurs pistes audio, toutes les pistes sont lues simultanément. Comme je souhaite débuter mon podcast uniquement par une introduction musicale de quelques secondes, je vais décaler la piste vocale (qui correspond à l’enregistrement effectué en première partie) de 10 sec pour que sa lecture ne commence que 10 sec plus tard. Pour cela, j’effectue un ajustement temporel comme expliqué dans la section 2.b.
A ce stade, si je lance la lecture à partir du début, on entend bien uniquement de la musique les dix premières secondes puis au-delà vient s’ajouter la voix ce qui bien sûr n’est pas satisfaisant. Il existe (au moins) trois façons de réussir une bonne transition entre le jingle initial et le début du podcast.
On fait commencer la partie vocale juste après la fin du jingle
La fin du jingle et le début du podcast se superposent quelques secondes avant que la musique ne s’arrête complètement.
la troisième approche est similaire à la précédente sauf que la durée ou les deux pistes vont se superposer est un peu plus longue et que le mixage entre voix et musique est plus travaillé : on diminue le volume de la musique durant les moments de parole pour la remettre à son niveau nominal pendant les périodes de silence.
Dans les trois cas, pour que cette transition soit la plus harmonieuse possible et éviter un arrêt brutal de la partie musicale, on va être amené à utiliser l’outils d’enveloppe. Pour mettre en oeuvre cet outil, il suffit de cliquer sur l’icone encadré ci-dessous
Aussitôt chacune des pistes est encadrée par deux lignes bleues représentant les seuils minimal et maximal du volume sonore de chacune d’elles.
En positionnant le curseur sur la piste qui nous intéresse celui-ci prend la forme d’une paire de petits triangles qui se superposent. En cliquant sur la souris, vont apparaître deux paires de petits carrés blancs (un sur chacune des deux lignes bleues puis deux situés à la jonction des parties grises claires/foncées). Il est possible de déplacer verticalement ces carrés ce qui va avoir pour effet de modifier la courbure des lignes bleues et ainsi de modifier le volume sonore de la piste à partir de la position de ces carrés. Ces carrés jouent le rôle de balises que l’on peut poser à plusieurs endroits de la piste pour moduler sur une portion voire la totalité de la piste le volume sonore comme on peut le voir ci-dessous.
On peut se poser la question du rôle de la paire de carrées intérieurs. On a vu que les carrés extérieurs permettaient en courbant les lignes bleues de modifier le volume sonore qui ne peut dépasser le volume nominal. Le déplacement de ces carrés entraîne celui des carrés intérieurs. Néanmoins, il est possible de déplacer directement ces derniers et de les positionner au dessus de leur position initiale et ainsi d’augmenter le volume qui du coup sera plus élevé que le niveau nominal. On dispose donc de deux leviers nous permettant de diminuer le son (les carrés extérieurs) ou de l’augmenter (les carrés intérieurs).
Les mixages 1. et 2. étant assez proches, je vais directement présenté le second. Sur les 10 sec qui précèdent le début de la piste vocale, je vais conserver le niveau sonore musical durant les 8 premières secondes puis à partir de là diminuer celui-ci progressivement jusqu’à le réduire au silence à la quatorzième seconde soit 4 sec après le début du podcast. Pour cela, en utilisant l’outils d’enveloppe présenté juste avant, j’obtiens un simple fondu en fermeture de la piste musicale qui se termine après 14 sec.
Le mixage 3. toujours réalisé à l’aide de l’outils d’enveloppe permet d’alterner pendant les premières secondes du podcast la partie musicale et la partie vocale.
4. Mixage de la fin du podcast et du jingle final
Dans la dernière partie de ce tutoriel, nous allons voir comment terminer notre podcast grâce à l’ajout d’une musique finale. La démarche étant très similaire à l’ajout d’une introduction musicale présentée en détail dans la section précédente, je ne vais pas refaire un présentation aussi détaillée. Pour commencer, j’importe le fichier contenant le morceau qui va servir de jingle final. Même si, comme pour l’introduction musicale, on peut imaginer plusieurs transitions, je vais ici limiter mon choix à un simple fondu en ouverture (note : Audacity possède une fonction « fondu en ouverture » que nous avons utilisée dans la première section mais qui effectue un fondu très basique et moins poussé que ceux que nous avons et allons effectuer). Tout d’abord, je déplace (par ajustement temporel) le jingle final jusqu’à la fin de la piste vocale. Plus précisément, je place le début du jingle 3 sec avant la fin de l’enregistrement vocal.
Ensuite, à l’aide de l’outil d’enveloppe, en partant de zéro j’augmente progressivement le volume de la partie musicale jusqu’à atteindre le volume nominal 3 sec plus tard puis je laisse à ce niveau pendant 5 sec et enfin pour ne pas arrêter brutalement le jingle, j’effectue un dernier fondu en fermeture, toujours à l’aide de l’outils d’enveloppe et je laisse une période de silence de 2 sec au cas ou l’auditeur enchaîne avec la lecture d’un autre enregistrement.
En mettant bout à bout toutes les parties, voici le podcast dans son intégralité :
Voilà notre podcast terminé ! Il ne reste plus qu’à le convertir en un format reconnu par un lecteur audio comme le MP3. Audacity permet la sauvegarde d’un projet avec un format (.aup3) qui est propre au logiciel et qui permet d’y retravailler ultérieurement. Cependant ce format n’est pas reconnu et ne peut donc être lu par d’autres applications. Pour rendre le projet lisible par un lecteur audio, il faut le convertir (ou l’exporter) dans un format audio standard. Audacity permet l’exportation sous de nombreux formats :
certains garantissent une qualité (au moins) CD mais produisent des fichiers volumineux, d’autres sont des formats compressés avec une qualité audio moindre mais qui vont créer des fichiers de plus petite taille.
5. En conclusion
Audacity est un logiciel que j’ai découvert en cours de musique au collège. Depuis, je l’utilise occasionnellement pour faire du mixage audio. Lorsque j’ai dû me familiariser avec ce logiciel, j’ai trouvé de nombreux tutoriels sur internet mais tous ne faisaient que la description (plus ou moins détaillée) des différentes fonctionnalités, ce qui rendait leur lecture peu agréable. J’ai tenté de réaliser ici le tutoriel que j’aurais aimé lire pour pouvoir utiliser rapidement cet outils sans forcément passer par la lecture de fonctionnalités dont je n’aurais peut-être jamais l’utilité. Une mise en situation simple, juste pour démarrer et se familiariser avec les fonctions de base …
Nous pensons souvent que le logiciel de mathématiques GeoGebra permet uniquement de construire des figures géométriques en 2D ou en 3D. Mais en réalité, GeoGebra permet de faire beaucoup plus de choses… Dans ce tutoriel, je vous propose de découvrir l’une des autres fonctionnalités de GeoGebra : le module Calcul formel, avec l’application GeoGebra Classique 6. Ce module vous permettra de résoudre des équations, factoriser et développer des expressions…
Dans ce tutoriel, j’utilise le module Calcul formel avec l’application GeoGebra Classique 6, mais il est également possible de l’utiliser avec une autre application GeoGebra. Dans ce cas, ce tutoriel pourra vous éclairer sur certains points.
Installer et lancer l’application GeoGebra Classique 6
Pour ouvrir le module Calcul formel, il faut, au préalable, lancer l’application GeoGebra Classique 6. Celle-ci est gratuite, utilisable et téléchargeable hors ligne sur Windows, iOS, Mac, Android et Linux.
Pour accéder à l’application GeoGebra Classique 6, cliquez sur ce lien. Vous devriez arriver sur la page suivante du logiciel GeoGebra (l’application qui nous intéresse est entourée en rouge) :
Une fois arrivé à cette page, vous avez 2 possibilités : soit vous décidez de télécharger l’application en cliquant sur le bouton Télécharger (1). Une fois que vous l’avez téléchargée, ouvrez l’application. Sinon, vous pouvez aussi choisir de lancer l’application dans votre navigateur, sans la télécharger, en cliquant sur le bouton Lancer (2). L’application va alors s’ouvrir dans un nouvel onglet de votre navigateur.
Dans les deux cas, la fenêtre ouverte est la même et doit être celle ci-dessous.
Ouvrir le module Calcul formel
Une fois l’application GeoGebra Classique 6 ouverte, vous arrivez donc sur la fenêtre d’accueil. Pour ouvrir le module Calcul formel de l’application, il vous suffit de cliquer sur Calcul formel (entouré et indiqué par une flèche en rouge ci-dessous) dans la petite fenêtre à droite de votre écran, qui propose différents modules :
Si cette petite fenêtre venait à disparaitre (un seul clic suffit pour ça), allez dans le menu, en haut à droite (1), puis une fois le menu ouvert, cliquez sur Associations (2) et enfin sur Calcul formel (3). Les étapes sont ci-dessous :
Une fois que vous avez cliqué sur Calcul formel, la fenêtre suivante devrait ainsi s’ouvrir, indiquant que vous êtes arrivés sur le module Calcul formel de l’application :
Quelques outils de Calcul formel à connaître
Une fois que vous êtes arrivés sur la fenêtre du module Calcul formel, vous remarquerez la présence en haut à gauche d’une barre d’outils présentant les différents outils de la fenêtre :
Parmi les différents outils proposés, nous allons nous intéresser tout d’abord aux outils Evaluer (1), Numérique (2), Conserver la saisie (3) et Effacer (4).
L’outil Evaluer (1) permet d’évaluer une expression, ou autre, de manière exacte. Il est déjà sélectionné automatiquement à l’ouverture de la fenêtre.
Au contraire, l’outil Numérique (2) permet d’évaluer une expression (ou autre) de manière approchée. Il donnera donc des résultats approchés.
Voici un exemple pour vous montrer la différence entre les outils Evaluer et Numérique :
Conseil : Je vous conseille donc fortement de laisser l’outil Evaluer (1), notamment pour résoudre des équations. Si vous voulez avoir une solution approchée, dans ce cas sélectionnez l’outil Numérique (2).
L’outil Conserver la saisie (3) vous permet de conserver l’expression saisie. Cet outil peut être utilisé dans le cas où l’on voudrait réutiliser la saisie pour la suite.
Voici un exemple pour faire la différence entre Conserver la saisie et Evaluer :
Enfin, l’outil Effacer (4), permet d’effacer une saisie ou une erreur, en sélectionnant l’objet que l’on souhaite supprimer.
Factoriser des expressions
Commençons par l’outil Factoriser, qui permet de factoriser des expressions.
Rentrez tout d’abord dans le champ de saisie l’expression que vous souhaitez développer (1). Notez que GeoGebra a simplifié l’expression que j’ai mise en exemple (même si cela n’a aucune importance). Ensuite, sélectionnez la case à gauche de la première saisie où est indiqué son numéro et qui doit devenir bleu foncé (2). Puis, cliquez sur l’outil Factoriser (3) pour factoriser l’expression.
Enfin, GeoGebra vous renvoie la forme factorisée de l’expression rentrée (4). Attention cependant : si GeoGebra arrive à bien factoriser tous types d’expressions, il a énormément de mal à factoriser des polynômes.
Développer des expressions
Passons maintenant à l’outil Développer, permettant de développer des expressions. Prenons pour exemple l’expression (2x+1)(21x-72), que l’on cherche à développer. Entrez cette expression dans le champ de saisie (1), puis appuyez sur l’outil Développer (2).
La forme développée de l’expression apparaît alors (3). Notez qu’avec des expressions comme celle-ci, en passant au champ de saisie suivant, GeoGebra développe tout seul l’expression.
Substituer des expressions
L’outil Substituer, permet, quant à lui, de remplacer une expression ou une variable par une autre (donc de la substituer😉)
Rentrez dans le champ de saisie l’expression que vous souhaitez substituer (1). Par exemple, ici, l’expression 3x+5. Puis, sélectionnez le champ de saisie et cliquez sur l’outil Substituer (2).
Une fenêtre va alors s’ouvrir (ci-contre). Dans cette fenêtre, on vous demande de choisir l’expression ou la variable que vous souhaitez modifier (Ancienne expression) et par quelle expression ou variable vous désirez la remplacer (Nouvelle expression). Ici, j’ai choisi de remplacer la variable x par 2a. Enfin, pour valider, choisissez le mode de substitution : Evaluer (A), Numérique (B) ou Substituer (C). Dans l’exemple ci-contre, j’ai validé en cliquant sur Evaluer (A).
Remarquez qu’après la validation, la variable x a été remplacée par 2a et donc que l’expression a changé. Ce résultat aurait été le même en cliquant sur Numérique (B) mais aurait changé si j’avais remplacé x par une fraction (il l’aurait alors arrondi). Si j’avais choisi de valider en cliquant sur Substituer (C), le résultat, avec l’exemple, aurait été 3(2a)+5.
Résoudre des équations, des inéquations et des systèmes d’équations
Nous allons maintenant voir comment résoudre des équations, des inéquations ainsi que des systèmes d’équations à plusieurs inconnues avec le module Calcul formel de GeoGebra Classique 6.
Commençons par la résolution d’une seule équation. Pour cela, j’ai pris pour exemple l’équation 7x2+42x-21.
Même protocole que précédemment : rentrez l’équation que vous souhaitez résoudre dans le champ de saisie puis sélectionnez le. Arrivé là, vous avez alors deux manières de résoudre l’équation : soit de manière exacte (GeoGebra renvoie la valeur exacte de la solution) avec l’outil Résoudre (1), ou de manière approchée (GeoGebra renvoie alors une valeur approchée avec 2 chiffres après la virgule) avec l’outil Résoudre numériquement (2).
Une fois que vous avez cliqué sur l’un de ces deux outils, GeoGebra renvoie la ou les solutions sous la forme d’un ensemble (avec les accolades). Vous remarquerez, ci-contre, que les solutions de l’équation, obtenues avec l’outil Résoudre (1) sont les solutions exactes, au contraire de celles obtenues avec l’outil Résoudre numériquement (2).
Dans l’exemple ci-dessus, j’ai résolu l’équation 7x2 + 42x – 21 = 0. Mais si vous voulez résoudre une égalité différente, il vous suffit simplement de réécrire votre égalité dans le champ de saisie. La méthode vue pour résoudre des équations fonctionne également très bien pour résoudre des inéquations (pensez juste à remplacer le = par < ; ≤ ; >ou ≥). Petits exemples ci-dessous :
Pour résoudre un système d’équations à plusieurs inconnues, il s’agit du même principe, à la seule différence que cette fois-ci, il y aura plusieurs équations à résoudre en même temps. Alors, comment faire ?
Vous pouvez tout d’abord écrire les différentes équations du système puis sélectionner les champs de saisie, pour enfin appuyer sur l’outil Résoudre (entouré en rouge).
Ou bien, rentrez dans les champs de saisie les équations du système, puis dans le champ de saisie suivant, rentrez, entre accolades, les numéros des lignes des équations du système. Ceux-ci doivent être précédés de $ et séparés par une virgule (1). Enfin, appuyez sur l’outil Résoudre (2).
GeoGebra nous renvoie alors les valeurs des inconnues du système.
Et vous pouvez, grâce à cette méthode, résoudre des systèmes avec un grand nombre d’inconnues et d’équations. Exemple ci-contre :
Dérivé et primitive
Avec le module Calcul formel de GeoGebra, on peut également faire de la dérivation et calculer des intégrales.
Afin de trouver la dérivé d’une fonction, il faut tout d’abord la définir. Pour ce faire, rentrez dans le champ de saisie l’expression de la fonction (uniquement).
Ensuite, cliquez sur le rond blanc à gauche de l’expression saisie (indiqué par la flèche rouge ci-dessus). Il permet d’afficher la fonction sur le graphique à côté, ainsi que lui donner un nom. Résultat ci-dessous :
Enfin, appuyez sur l’outil Dérivé (1). La fonction dérivée apparaît alors (2). Elle a également été nommée automatiquement.
Le module Calcul formel permet aussi de calculer des primitives ou des intégrales. Rentrez alors l’expression dont vous cherchez la primitive (1), puis cliquez sur l’outil Primitive (2).
L’intégrale de l’expression nous est ensuite renvoyée (3). On peut, de plus, utiliser d’autres variables que x, et en même temps.
Sauvegarder son travail
Vous avez réalisé des calculs avec le module Calcul formel de GeoGebra, et vous désirez les conserver. Pour les sauvegarder, c’est simple : il suffit de cliquer sur les trois barres noires horizontales (qui correspondent au menu) en haut à droite de la fenêtre (1). Ensuite, dans le menu qui s’affiche, cliquez sur Sauvegarder (2).
Enfin, une fenêtre s’affiche vous demandant de vous connecter à votre compte GeoGebra pour sauvegarder votre travail. Connectez-vous à votre compte ou créez-en un (3). Sinon, cliquez sur Continuer sans sauvegarder (4) pour enregistrer votre travail ailleurs que sur GeoGebra.
Conclusion
En conclusion, le module Calcul formel de GeoGebra (Classique 6😁) permet de développer, factoriser et substituer des expressions, ainsi que résoudre des équations, inéquations et systèmes d’équations, mais également dériver une fonction ou trouver l’intégrale d’une expression. Ce module peut vous être utile, notamment si vous avez des difficultés en calcul formel, afin de vous entraîner et vous rendre plus accessible des choses qui peuvent vous sembler compliquées, tout en utilisant peu d’outils.
A la recherche d’un moyen de gérer tous vos serveurs de jeux, serveurs vocaux, et autres avec une seule et même interface facile à utiliser ? Le logiciel linux Pterodactyl est fait pour vous ! Sous forme d’un site lors de l’utilisation, il va vous permettre de créer et administrer vos serveurs de jeux et vocaux.
Le tutoriel peut paraître long, mais a été simplifié le plus possible. L’installation qui vous est présenté est pensée pour un cadre expérimental et de découverte de l’outil Pterodactyl. Cela veut donc dire que le tutoriel ne vous permettra pas de l’utiliser sur des serveurs de productions.
Teaser vidéo
Dans ce tutoriel, vous apprendrez à :
Installer une machine virtuelle sur son propre ordinateur,
Installer et configurer le système d’exploitation Ubuntu Server,
Installer et configurer Pterodactyl à l’aide d’un script
Utiliser quelques fonctionnalités de Pterodactyl (création de serveurs, création d’utilisateurs et présentations des outils pour gérer un serveur)
Qu’est-ce que Pterodactyl ?
Développé par Dane Everitt (et d’autres contributeurs) et disponible depuis 2015, Pterodactyl est un SaaS (« Software as a Service », « Logiciel en tant que service » en français, c’est-à-dire un logiciel plus généralement installé et utilisé sur un serveur) uniquement disponible sur des systèmes d’exploitation linux. Pour rappel, un serveur n’est rien d’autre qu’un ordinateur sans interface graphique (c’est-à-dire uniquement utilisé en ligne de commande) qui sert de point relais pour la communication entre d’autres machines sur internet et/ou à délivrer des services (Serveur Web, Mail, etc.). C’est pour cette raison que Pterodactyl peut être installé sur un ordinateur linux avec interface graphique. Vous apprendrez à l’installer pour une utilisation sur serveur. Sachez que l’installation sur un système d’exploitation linux avec interface graphique est strictement identique.
Pterodactyl est conçu avec le principal objectif d’assurer une sécurité avancée. Par exemple, chaque serveur qui sera créé sera techniquement séparé des autres, c’est-à-dire que si il y a un problème sur un des serveurs, cela ne se répercutera pas sur les autres serveurs.
Une fois l’importante étape qui est l’installation de Pterodactyl, vous pourrez :
Créer très simplement une multitude de serveurs de jeux, vocaux, de bots, etc.
Administrer les serveurs facilement, avec des fonctionnalités supplémentaires intégrées par défaut :
Création et gestion de backups pour les serveurs
Création de tâches programmables pour s’exécuter automatiquement, répétitivement, etc.
Création et gestion de bases de données.
(fonctionnalité très avancée) Ajouter des plugins payants proposés par Pterodactyl afin d’encore plus simplifier l’administration des serveurs (installation en un clic de plugins/mods pour les serveurs Minecraft par exemple).
Gestion avancée d’utilisateurs : Vous avez un projet de jeu mais votre ami en a aussi un complètement différent du votre ? Pterodactyl a un système de gestion de permissions, de propriété de serveur, etc.
Installation sur une machine virtuelle (VM)
⚠ Pour le reste du tutoriel, si vous avez un problème, des questions, des erreurs, etc. Je suis à votre disposition pour vous aider à nsi.aide.thomas@gmail.com ⚠
Je pense que ni vous ni moi louerait un serveur pour expérimenter Pterodactyl, c’est pour cette raison que vous ferez l’installation sur votre ordinateur personnel. Si vous êtes déjà sur une distribution Linux supportée par Pterodactyl tout va bien, vous pouvez passer cette étape. Les distributions supportées sont :
Système d’exploitation
Version
Supporté ?
Notes
Ubuntu
18.04
✅
20.04
✅
22.04
✅
Le tutoriel est basé sur ce système d’exploitation (conseillé).
CentOS
7
✅
Des dépôts, serveurs contenant des « paquets » (voir la définition d’apt1) supplémentaires sont requis.
8
✅
Des manipulations supplémentaires sont requises pour ce système d’exploitation. Cependant nous ne verrons pas son installation. Ce lien ainsi que la documentation officielle va vous permettre d’installer les prérequis supplémentaires.
Debian
10
✅
11
✅
1 Expliqué plus loin : Ctrl + F est votre ami (La définition d’apt est dans la partie Prérequis)
Sinon il va falloir installer un de ces systèmes d’exploitations dans une VM sur votre ordinateur. Une Virtual Machine est sous la forme d’un logiciel et simule un autre ordinateur sur son propre ordinateur. Cela permet d’avoir par exemple sur un MacBook un ordinateur virtuel Windows. Pour installer un système d’exploitation sur une VM, nous avons besoin d’un fichier de type ISO (généralement appelé image ISO). Avant, les systèmes d’exploitations s’installaient grâce à des DVD (aujourd’hui, c’est moins répandu). Une image ISO est l’équivalent d’un disque (DVD) mais en version numérique. Voilà pourquoi on utilise ce type de fichier. Pour ce tutoriel, nous utiliserons cette image ISO (si le lien a un souci, allez sur ubuntu.com/download/server puis cliquez le bouton vert en plein milieu « Download Ubuntu Server XX.XX.X XXX »). Nous utiliserons ce fichier plus tard dans le tutoriel.
Nous allons utiliser le logiciel VirtualBox proposé par Oracle. Commençons par télécharger le logiciel ici, le « VirtualBox 7.0.4 platform packages » (selon votre système d’exploitation) ainsi que le « VirtualBox 7.0.4 Oracle VM VirtualBox Extension Pack » juste en dessous. Exécutez l’installeur (« VirtualBox-7.0.4-154605-Win », notez que le nom peut différer un peu avec cet exemple). Suivez les instructions, puis démarrez le logiciel. Voici comment il se présente :
Nous allons être efficace : Cliquez sur le bouton encadré en rouge, puis « Extensions ». Cliquez ensuite sur « Install », importez le second fichier que nous avons téléchargé (« Oracle_VM_VirtualBox_Extension_Pack-7.0.4.vbox-extpack » ou nom similaire) et cliquez sur « Installation » (sans oublier de lire, 😉, puis accepter les conditions d’utilisations). L’extension devrait être ajoutée et visible dans la liste.
Pour revenir à l’interface de bienvenue, cliquez sur le bouton encadré en rouge et allez sur « Bienvenue ». Ici nous allons pouvoir créer notre machine virtuel. Pour se faire, vous avez le bouton « Nouvelle », qui vous ouvre cette fenêtre :
Nom : Un nom pour votre VM, cela a peu d’importance, c’est pour vous y retrouver.
Folder : La localisation des fichiers de la VM.
ISO Image : Il faut mettre ici le fichier ISO que nous avons téléchargé au début du tutoriel qui contient le système d’exploitation.
Edition / Type / Version : Ces options se sont normalement grisées après avoir importé l’image ISO. De plus ne cochez pas la petite case Skip Unattended Installation.
Nous devons maintenant choisir le nom d’utilisateur, ainsi qu’un mot de passe. Evitez les noms d’utilisateurs farfelus, choisissez quelque chose de simple, sans espace, ni majuscule. Changez également le mot de passe.
Hostname : Chaque appareil connecté à son réseau local a un « hostname ». C’est son nom sur le réseau. Choisissez-en un qui vous permettra de le reconnaitre. Notez qu’il doit être d’au minimum trois caractères et ne peut être écrit qu’avec des caractères alphanumériques ainsi que des petits tirets et des points (mais ne peut pas se terminer par un point). « ubuntu-vm » est un très bon choix par exemple.
Domain Name : ¯\_(ツ)_/¯ Mais pas important dans notre cas.
Ne cochez pas Install in Background ni Guest Additions.
Passons à l’allocation des ressources à notre VM, c’est-à-dire combien de mémoire vive (mémoire volatile pour stocker les données et programmes en cours d’exécution) et de cœurs du processeur (partie qui exécute des instructions, plus il y a en, plus le processeur peut faire des tâches simultanément). Il faut choisir cela en fonction des ressources de son ordinateur. Dans notre cadre expérimental, nous n’avons pas besoin de beaucoup de ressources. Je vous conseille au strict minimum 2 Go (2048 Mo) ainsi que 2 cœurs ou sinon 4 Go (4096 Mo) de mémoire vive et 4 cœurs.
Nous allons maintenant allouer le stockage. Encore une fois, faites cela en fonction de l’espace que vous avez. 25 Gio fera très bien l’affaire.
Nous avons ensuite un récapitulatif des caractéristiques de la VM. On peut appuyer sur « Finish ».
La VM s’est automatiquement lancée, une nouvelle fenêtre est apparue. Au passage, n’hésitez pas à fermer le menu à droite avec le bouton encadré en rouge.
Avant de se lancer dans la configuration du système d’exploitation, nous allons éteindre la machine en allant dans Machine (encadré en jaune), puis Extinction par ACPI. Attendez que la fenêtre se ferme. Ensuite allez dans le bouton Configuration, Réseau et pour Adapter 1 changer l’option Mode d’accès réseau par « Accès par pont » et pour l’option Name, choisissez le nom de votre carte réseau. Je ne connais pas ma carte réseau… Allez vérifiez que l’image ISO dans Stockage (Menu à gauche) est présente au niveau du « Contrôleur : IDE ». Si ce n’est pas le cas, cliquez sur le bouton DVD avec un + et ajoutez le fichier ISO (comparez les noms pour savoir si c’est le bon).
Maintenant, lancez la machine virtuelle, et vous devriez avoir à nouveau la première page de configuration où l’on sélectionne la langue. C’est parti !
Installation et configuration du système d’exploitation
Sachez que la souris n’existe pas ! Toutes les manipulations se feront aux claviers. Vous bougez avec les touches fléchés et appuyez sur la touche Entrée pour confirmer une action. Sélectionnez votre langue puis confirmez. Dans la page qui suit, vous avez 3 options en bas, prenez celle du haut, donc « Mise à jour vers le nouveau programme d’installation », confirmez puis patientez. Maintenant, vous pouvez choisir la langue de votre clavier :
Si vous allez sur un des menus déroulants (sur « French – French (legacy, alt.) » pour le menu Variant par exemple), vous pourrez appuyer sur la touche Entrée et changer la variante. Choisissez la première, « French » puis confirmez en allant sur « Terminé » (ou « Done »).
La page d’après vous donne la possibilité d’installer une version allégée de Ubuntu Server, mais dans notre cas, nous allons conserver la version classique, donc confirmez juste. La page suivante concerne la connexion avec le reste du réseau local. Vous ne devriez rien avoir à toucher, confirmez juste. On voit différentes informations intéressantes comme l’IP, c’est-à-dire son identifiant pour la reconnaitre par rapport aux autres, qu’aura notre machine et qui nous sera utile pour y accéder (vous pourriez avoir une IP différente de celle-là) ainsi que le nom de la carte réseau que l’on retrouve en gris en dessous.
Il n’y a rien à changer sur la page suivante, ni à la page d’après. Celle d’après est par rapport au stockage, mais tout est présélectionné correctement, donc il suffit de descendre sur le bouton Done et confirmer.
La seconde page est également en rapport avec le stockage. Je vais y aller pas à pas, suivez les étapes selon les images dans leur ordre.
Par défaut.Allez sur l’option où il y a le trait rouge, confirmez (touche Entrée) puis allez sur Unmount et confirmez.Allez sur l’option où il y a le trait rouge, confirmez puis allez sur Edit et confirmez.Ici, il faut changer la valeur de Size. Mettez la valeur entre les parenthèses (ici 22.996G). Attention à mettre un point et pas une virgule ! Il faut également changer la valeur de Mount. Allez dessus, appuyez sur Entrée, puis choisissez le « /« . Puis allez sur Save en bas et confirmez. Et pour finir allez sur Done et confirmez. Une popup apparaitra et vous demandera si vous êtes sûr. C’est le cas, donc confirmez.
Sur la page suivante, vous devez remettre les informations que nous avions mises lors de la configuration de la VM.
Your name : Ce n’est pas important, j’ai personnellement l’habitude de mettre la même chose que Pick a username.
You server’s name : Il faut mettre la même chose que le hostname (information renseignée lors de la création de la VM).
Pick a username : C’est le nom d’utilisateur, il doit être le même que username (information renseignée lors de la création de la VM).
Choose a password / Confirm your password : Mettez le mot de passe que vous aviez mis lors de la création de la VM.
Sur le page suivante, le service vous propose d’installer OpenSSH server. C’est un service qui vous permet d’accéder à distance à la console du serveur. C’est très pratique, on peut entièrement faire les installations avec, mais de la manière dont je me suis (mal) géré, je ne l’utiliserai que beaucoup plus tard dans le tutoriel pour une pauvre petite action. Déplacez vous en face de l’option (sauf si vous y êtes déjà) pour installer OpenSSH (encadré en rouge) et appuyez sur la touche Entrée, puis allez sur Done et confirmez.
La page qui suit vous propose une liste d’autres services à installer. Si nous avons besoin de ces services, nous les installerons en temps voulu. Confirmez en allant sur Done, et puis patientez, toutes les installations et configurations sont en train de se faire. Vous avez une page de log. Cela peut durer un certain temps, pas d’inquiétude. Lorsque l’installation sera achevé, le second bouton encadré en rouge changera, et deviendra Reboot Now. Allez dessus, confirmez puis patientez.
Une fois cela fait, une bonne quantité de texte va défiler, il faut attendre que ça se termine. Il est possible que l’image en dessous ne corresponde pas à ce que vous avez, mais ce n’est pas grave, sauf si il y a du rouge à la dernière ligne de texte… Si au bout d’un moment la ligne rouge reste et que plus rien d’autres se fait, rechercher le problème sur internet ou contactez moi
Sauf pour cette erreur là qui est « normale », il vous suffit simplement d’appuyer sur la touche Entrée.
Lorsque vous pourrez écrire, c’est que vous pourrez vous connectez, comme vous pouvez le voir sur l’image en dessous (ne faites pas ce que j’ai fait).
Ecrivez alors votre nom d’utilisateur puis appuyez sur la touche Entrée.
Une nouvelle ligne apparait, qui vous invite à écrire votre mot de passe, mais lorsque vous le faites… Rien n’apparait 😭. Mais détendez-vous ! C’est normal. Lorsqu’il faut écrire un mot de passe, linux ne fait jamais apparaitre de caractères, même pas des « * », mais il est quand même écrit ! Prenez donc le temps d’écrire le mot de passe, car souvent on l’écrit mal sans s’en rendre compte et du coup il nous le refuse.
😐Enfin ! On a réussi 😁
Installation de Pterodactyl
Bon, c’était déjà bien sportif l’installation de cette VM et de ce linux… Je peux comprendre que certains d’entre vous soyez saturés. Et c’est pour cela que je vous propose une méthode assez simple pour installer Pterodactyl. Nous utiliserons un script. Il faut savoir que c’est un script non officiel, et que Pterodactyl ne le supporte pas. En cas de souci lors de l’installation avec ce script, contactez moi. Voici un lien vers la documentation officielle pour installer manuellement Pterodactyl (vous verrez, vous apprendrez beaucoup de chose).
Prérequis
Voici un récapitulatif de quelques commandes linux qui seront utilisées avec une courte explication :
sudo : Terme à mettre au début d’une commande que l’on souhaite exécuter avec les plus hautes permissions. Il faut faire très attention car une mauvaise manipulation peut endommager définitivement le système d’exploitation, qui nécessiterait une réinstallation. Lorsque vous utiliserez une commande avec ce terme au début, il faudra mettre son mot de passe pour pouvoir l’exécuter.
apt : Simplement : L’App Store version ligne de commande. Plus précisément : Commande qui permet de gérer des paquets. Les paquets sont des archives permettant d’installer des logiciels, stockés dans des dépôts, que l’on peut changer si nécessaire.
apt update : Recherche si il y a des mises à jour disponibles.
apt upgrade : Applique les mises à jour trouvées (se lance donc après la commande apt update).
apt install [nom_paquet] : Installe le paquet donné en paramètre (il faut remplacer [nom_paquet] par le nom d’un paquet, par exemple nano).
reboot : Redémarrage la machine virtuelle.
su : Permet de se connecter en tant qu’un autre utilisateur. Nous utiliserons cette commande pour accéder à l’utilisateur « root ».
Une notion a maîtriser est le terme « root ». Ce terme est le nom de l’utilisateur avec les plus hauts privilèges possibles. Il faut faire très attention car une mauvaise manipulation peut endommager définitivement le système d’exploitation, qui nécessiterait une réinstallation.
Quelques notions à comprendre en rapport avec Pterodactyl :
Le « panel » (le front-end) : La partie graphique de Pterodactyl. Elle envoie des ordres au daemon.
Le « daemon », également appelé « wings » (le back-end) : La partie de Pterodactyl qui crée véritablement les serveurs, qui fait les actions que le panel lui demande.
Le « Node » : C’est la configuration du daemon. C’est avec lui que nous renseignerons diverses informations comme par exemple la quantité de ressources allouées (la mémoire vive, le processeur et l’espace disque).
Le terme « port » : Ce n’est pas réservé à Pterodactyl. Un port est un système permettant aux logiciels (côté client comme côté serveur) de recevoir ou d’émettre des informations. Il y a 65536 possibilités de ports qui sont classifiés dans 3 catégories : les « ports reconnus » qui sont réservés à des processus spécifiques (le port 80 pour héberger un site par exemple), les « ports enregistrés » qui sont assignés par L’IANA et pour finir les ports dynamiques qui sont généralement utilisés pour des communications temporaires. Vous pouvez donc utiliser les ports que vous voulez à l’exception de la plage 0 à 1023 (sauf si le service utilise un de ces ports par défaut, comme un site internet). Notez que beaucoup de logiciels ont un port par défaut, donc privilégiez l’utilisation de celui-ci (pour Minecraft c’est par exemple le port 25565) Une petite liste répertoriant quelques ports…
Nous devons d’abord vérifier si il y a des mises à jour disponibles :
cosmos@ubuntu-vm:~$ sudo apt update
Beaucoup de texte apparait, puis lorsque nous avons à nouveau cosmos@ubuntu-vm:~$ (cosmos le nom d’utilisateur et ubuntu-vm le « hostname ») qui apparait, c’est que la commande a fini de s’exécuter.
119 paquets peuvent être mis à jour. Exécutez « apt list --upgradable » pour les voir.
cosmos@ubuntu-vm:~$
Nous avons donc 119 paquets à mettre à jour. Et bien allons-y :
cosmos@ubuntu-vm:~$ sudo apt upgrade
Du texte défilera, puis vous aurez sûrement 5 dernières lignes similaires à celles-ci (peut-être en anglais) :
Si c’est écrit en français, vous devrez confirmer en appuyant sur le touche O de votre clavier puis appuyer sur la touche Entrée et si c’est en anglais, ce sera pareil sauf qu’il faudra appuyer sur la touche Y de votre clavier. Maintenant patienter, ça peut prendre un moment selon votre connexion internet.
Notez que j’ai eu une « pop-up » avec fond violet qui m’a informé d’une nouvelle version du « kernel » (le « noyau » du système d’exploitation). J’ai juste appuyé sur Entrée.
Ensuite, j’ai eu une autre « pop-up » avec une liste de services que je peux redémarrer. Dans tous les cas, nous redémarrerons le système, donc juste appuyer sur le touche Tab (la touche à gauche de la touche A sur votre clavier) deux fois, afin que Cancel soit avec une surbrillance rouge/orange puis appuyer sur Entrée.
Pour terminer, nous allons redémarrer la machine virtuelle, afin que tout soit correctement appliqué :
cosmos@ubuntu-vm:~$ sudo reboot
Installation rapide (avec script)
⚠ Notez que le script ne fonctionne pas sur CentOS 7 et 8 ! Suivez la documentation officielle pour installer Pterodactyl sur ces deux systèmes d’exploitations. ⚠ Les autres systèmes d’exploitation du tableau au début de l’article sont eux compatibles.
Avant toute chose, nous aurons besoin de savoir l’adresse IP de la machine virtuelle pour plus tard. Pour se faire, utilisez la commande ip addr:
cosmos@ubuntu-vm:~$ ip addr
Dans tout ce blabla bizarre, ce que nous cherchons est encadré en rouge ! Sachez que l’IP commencera toujours par 192.168 (si vous avez bien suivi le tutoriel) puis les deux autres nombres pourront varier. Notez l’adresse IP pour plus tard !
Nous allons utiliser le script d’installation écrit par vilhelmprytz. La page github du script est consultable ici. Pour s’assurer du bon fonctionnement du script, nous allons « passer en root », c’est-à-dire se connecter avec l’utilisateur root, pour se faire :
cosmos@ubuntu-vm:~$ sudo su
Mettez votre mot de passe, et vous remarquerez qu’à la place de votre nom d’utilisateur il y a le terme « root ». Exécutez maintenant cette ligne de commande :
L’installeur se lance et vous propose différentes options.
Ici, vous dites ce que vous souhaitez installer. Nous voulons le panel et le daemon, donc l’option 2.Vous configurez le nom de la base de donnée où seront stockés les informations, le compte utilisateur pour accéder à cette base de donnée et son mot de passe. Pour database name et database username, laissez par défaut, c’est-à-dire appuyez simplement sur Entrée. Concernant le mot de passe, c’est vous qui décidez. Personnellement j’ai juste appuyé sur Entrée pour que ça génère un mot de passe automatiquement. Vous devez maintenant choisir une Timezone, mettez ce que j’ai mis, c’est-à-dire Europe/Paris.Mettez une email valide, mais dans un cadre d’expérimentation, vous pouvez prendre une « email poubelle ».Créez le premier compte utilisateur admin pour le panel. L’email ne doit pas obligatoirement être valide. Vous devrez vous rappelez de username et du mot de passe pour vous connecter.Fully Qualified Domain Name. C’est l’IP (ou le nom de domaine) où est hébergé le panel. Notez que le panel et le daemon peuvent être installés sur deux serveurs séparés et cette option prend son sens dans ce cas là. Ici, ce sera sur la même machine, donc au final, ça revient au même. Donc, mettez l’IP de la machine virtuel que vous avez noté après avoir fait ip addr. Notez que le warning vous prévient que vous ne pourrez pas générer un certificat ssl pour sécuriser votre site (qu’il soit en https), ce qui n’est pas grave puisque nous faisons tout en local. « Let’s Encrypt » est un service gratuit permettant de générer des certificat ssl.Un pare-feu est très important, mais dans un cadre expérimental, ce n’est pas nécessaire. Mettez N puis confirmez.
On a ensuite un récapitulatif de la configuration puis nous devons confirmer que nous voulons cette configuration. Mettez Y et l’installation va débuter. Ensuite nous avons ceci :
Mettez no puis patientez. Et…Le script a fini d’installer le panel (le front-end), passons au daemon (le back-end). Mettez Y.Dans notre cas, le firewall est inutile. Mettez N.Ceci est pour permettre la création de bases de données pour les serveurs de jeux, vocaux, etc. C’est une fonctionnalité un peu avancé, donc pour ce tutoriel, sauf si vous vous y connaissez, mettez N.Puisque tout à l’heure, nous n’avions pas mis en place de certificat, il faut mettre N. Après avoir fait ça, mettez Y pour lancer l’installation.
L’installation est terminé, mais ce n’est pas encore fini…
Configuration du Node
Nous allons à présent configurer le Node. Il va falloir aller sur le panel. Mettez l’adresse IP de la machine virtuelle dans une page de votre navigateur.
Génial ! Connectez vous avec l’utilisateur créé plus tôt.Il y aura ici la liste des serveurs créés grâce au panel. Cliquez sur le bouton avec des engrenages. Il vous renvoie vers l’interface administrateur du panel. Ici c’est la partie pour administrer Pterodactyl, donc le panel, le daemon, etc. (pas les serveurs). Allez dans « Locations », puis « Create New ».Il faut savoir que l’on peut associer différents daemon à un même panel et la « location » permet de les catégoriser. Ce n’est pas vraiment important, mais mettez quelque chose qui a du sens pour vous y retrouver. Par exemple fr.home car le daemon est en France et hébergé chez vous. La description est facultative.Passons à la création d’un Node. Allez dans « Nodes », puis « Create New ».Cela peut faire peur, mais ne vous inquiétez pas, c’est simple :
– Name : Le petit nom que vous allez lui donner, pour vous y retrouver.
– Description : Une description (facultative).
– Location : Ce que nous avons créé il n’y a pas plus tard que 2 minutes.
– Node Visibility : Permet de le masquer dans la liste des Nodes disponibles lors de la création de serveurs. Dans notre cas, inutile, donc laissez Public.
– FQDN : Cela vous dit quelque chose non ? Mettez donc l’ip de votre machine.
– Communicate Over SSL : Il faut cocher la première option si le panel est sécurisé avec un certificat, ce n’est pas le cas, donc mettez la seconde option (c’est normal que la case soit rouge une fois cliquée).
– Behind Proxy : Si le daemon est derrière un proxy qui s’occupe de la connexion ssl, il faut mettre la seconde option. Je cite de la documentation : Si cette phrase n’a aucun sens pour vous, c’est que cela ne vous affecte pas. Alors, vous avez compris, laissez la première option 😉
– Daemon Server File Directory : Où sera sauvegardé le contenu des serveurs du node. Laissez par défaut.
– Total Memory : La quantité de mémoire vive que nous voulons allouer au Node. Il ne faut pas mettre la capacité maximale de la machine, car le système d’exploitation en nécessite un peu. Ici, je vais mettre 3Go. Notez que 1Go = 1024 MiB donc à multiplier par le nombre de Go que vous voulez.
– Memory Over-Allocation : La quantité en pourcentage de mémoire vive qui sera utilisé en plus si les 3Go sont complètement utilisés. En mettant -1, il n’y aura pas de limite et en mettant 0, cela empêchera de dépasser la quantité de mémoire allouée. Cela va dépendre de vos utilisations, mais puisque que nous expérimentons et que nous sommes limités à 4Go, je vais mettre 0.
– Total Disk Space : La quantité d’espace disque que nous voulons allouer au Node Il ne faut pas mettre la capacité maximale de la machine, car le système d’exploitation en nécessite un peu. Ici, je vais mettre 15Go. Notez que 1Go = 1024 MiB donc à multiplier par le nombre de Go que vous voulez.
– Disk Over-Allocation : Même chose que pour Memory Over-Allocation mais pour l’espace disque.
– Daemon Port / Daemon SFTP Port : Les ports utilisés par le daemon pour communiquer, écouter, etc. Pas touche !
Cliquez enfin sur « Create Node ».Il faut maintenant ajouter des allocations, c’est-à-dire des ports pour les serveurs qui seront créés. Pour IP Adress, mettre 0.0.0.0 signifie « toutes les adresses IPv4 de la machine locale », car une machine peut avoir plusieurs IPs. C’est ce que nous mettrons. IP alias est facultatif, ne nous en préoccupons pas. Et nous allons donc ajouter des Ports. On peut les ajouter un par un, avec un espace entre chaque port ou alors les écrire d’une certaine façon, par exemple utiliser un tiret : 25565-25575Et Bam ! Tout ça en moins de 10 secondes 😁 Mais ce n’est pas encore terminé !
Mais avant de continuer, nous allons avoir besoin d’utiliser OpenSSH (mentionné plus haut dans l’article). Pour vérifier que le service est installé et fonctionnel, chercher dans la barre de recherche de votre ordinateur « invite de commande » puis lancer l’application, puis taper la commande ssh.
Si vous avez une réponse, alors c’est bon ! OpenSSH est installé par défaut sur Linux et MacOS, pour Windows je ne suis pas sûr, donc voici un lien pour l’installer sur Windows.
Comment ça fonctionne ? Et bien c’est plutôt simple :
ssh username@ip
Vous avez donc compris, vous devez mettre votre d’utilisateur, puis « @ » suivi de l’IP de votre machine virtuelle par exemple : ssh cosmos@192.168.1.31 Il vous demande en suite le mot de passe du compte, et ici aussi, aucun caractère n’apparait mais c’est normal.
Et voilà, vous êtes connectés à distance (je vous rappelle qu’une machine virtuelle est un ordinateur séparé de celui sur lequel il est hébergé). L’avantage d’avoir fait tout ça, c’est que nous allons pouvoir faire des copier/coller… Et croyez moi, ce que vous allez copier/coller juste après, vous n’auriez pas aimé devoir le recopier… Cela à d’autres avantages comme avoir plusieurs consoles en simultané (rien n’empêche d’ouvrir 42 invites de commandes et se connecter avec), le défilement avec le souris, des consoles redimensionnables, etc.
Repassons sur Pterodactyl maintenant que vous vous êtes connectés en parallèle avec OpenSSH. Vous êtes donc dans l’onglet Configuration.
Cliquez sur Generate TokenCopiez la ligne (vérifiez que vous avez bien tout sélectionné) puis collez là (en faisant un clique droit pas un Ctrl+V) dans l’invite de commande où vous vous êtes connectés en ssh.Même si la mise en forme s’est fait la malle, y a bien écrit à la fin « Successfully configured wings ».
La configuration a bien été appliqué, mais le daemon (wings) n’est toujours pas lancé. On peut le lancer avec sudo wings
Pas de rouge… c’est rassurant ! Et si vous retournez sur le panel puis allez dans la catégorie « Node » vous verrez qu’un cœur vert apparait à côté du nom du Node.
En appuyant simultanément sur les touches Ctrl et C vous arrêterait le programme. tapez ensuite ces commandes :
cosmos@ubuntu-vm:/etc/pterodactyl$ cd /etc/systemd/system
Alors… Vous n’allez pas me croire… mais l’installation et la configuration de Pterodactyl est ENFIN terminée !
Installation d’un serveur Minecraft avec Pterodactyl
Pour installer un serveur Minecraft avec Pterodactyl, rendez-vous dans l’interface administrateur du panel puis dans la catégorie « Servers ». Puis cliquez sur « Create New ».
Dans « Core Details » :
– Server Name : Le nom du serveur qui apparaitra sur le panel. – Server Owner : Le propriétaire du serveur. Ecrivez les premiers caractères de l’adresse email du compte à qui appartiendra le serveur et celui-ci sera affiché dans la liste. – Server Description : Une description, c’est facultatif. – Start Server when Installed : Si coché, une fois l’installation terminé, le serveur se lancera automatiquement.
On passe à « Allocation Management » :
– Node : Le Node sera installé le serveur – Default Allocation : Le port par défaut associé au serveur. Ce sont les ports que nous avions ajouté dans la configuration du Node. Et dans ces ports, il y a le port 25565, le port par défaut de Minecraft. Mettons le. – Additional Allocation(s) : Si vous voulez allouer d’autres ports à ce serveur. Cela peut être utile si vous utilisez des plugins/mods en nécessitant (mais n’en ajoutez pas pour rien).
Puis à « Application Feature Limits » :
– Database/Backup/Allocation Limit : La limite du nombre de bases de données/backups/ports que le serveur aura. C’est-à-dire que les utilisateurs qui pourront créer ces éléments seront limités à ce nombre.Pour « Resource Management » :
– CPU Limit : Le pourcentage de ressource processeur que vous allouez au serveur. Un cœur correspond à 100 %. Cela veut dire que vous pouvez allouer un cœur et demi par exemple. Pour 2 cœurs -> 2 * 100 = 200 – CPU Pinning : Fonctionnalité avancé, cela permet de préciser si vous voulez que le serveur utilise un ou plusieurs cœurs en particulier. Ne vous embêtez pas avec cela, sauf si cela vous est vraiment nécessaire (laissez vide si vous ne voulez pas l’utiliser). – Memory : La quantité de mémoire vive que vous allez au serveur (en MiB). 1 Go = 1024 MiB – Swap : Utilise de l’espace de stockage comme mémoire vive. C’est-à-dire que si la quantité de mémoire vive est saturée, cela utilisera une quantité d’espace de stockage. C’est cependant à éviter car cela chute les performances. -1 ne met pas de limite et 0 n’en alloue pas. – Disk Space : La quantité d’espace de stockage que vous allouez au serveur (en MiB). – Block IO Weight : Fonctionnalité avancé que je n’ai jamais utilisé. – Enable OOM Killer : Permet de forcer l’extinction du serveur si il dépasse la limite de mémoire.
Passons à « Nest Configuration » :
– Nest : Catégorie classant différent fichier de configuration pour créer un serveur. – Egg : Le fichier de configuration pour créer un serveur. Vanilla Minecraft est le nom de la version classique de Minecraft. Forge Minecraft est utilisé pour les mods. Sponge n’est plus utilisé. Ignorez Bungeecord, c’est pour reliez différents serveurs Minecraft entre eux, c’est une notion avancé pour les administrateurs d’un serveur Minecraft. Pour finir, Paper est pour les plugins. – Skip Egg Install Script : Si vous cochez cette case, le script d’installation ne s’exécutera pas, dans notre cas, cela ne sert à rien. Continuons avec « Docker Configuration » : – Docker Image : Dans notre cas, c’est la version de java qui sera utilisé pour faire tourner le serveur Minecraft. Selon la version que vous voulez installer sur votre serveur Minecraft, il faut une version Java plus ou moins récentes. L’option « Or enter a custom image » est une fonctionnalité avancé, n’y prêtez pas attention.Et pour finir, « Startup Configuration » et « Service Variables » (ces options peuvent varier selon l’Egg que vous mettez) :
– Start Command : La commande qui lancera le serveur à chaque fois que vous appuierez sur le bouton « start ». N’y touchez pas, à moins de savoir ce que vous faites. – Server Jar File : Le nom du fichier Jar. Si vous ne savez pas ce qu’est un fichier Jar, n’y touchez pas. – Server Version : La version de votre serveur Minecraft. « latest » installe donc la dernière version stable et « snapshot » la dernière version snapshot. Vous pouvez aussi mettre le numéro d’une version.
Vous pouvez maintenant cliquer sur « Create Server ». Cliquez sur le bouton encadré en rouge pour quitter l’interface administrateur du panel.
Vous voyez à présent votre serveur dans la liste des serveurs disponibles.
J’en ai créé un autre pour vous montrer deux cas : On a le premier qui a fini de s’installer, on va pouvoir le démarrer alors que le second en train de s’installer, il faut donc patienter un peu.
Cliquez sur le serveur listé que vous venez de créer et une nouvelle interface apparait.
Vous avez au milieu une console, à droite 3 boutons pour respectivement démarrer, redémarrer et arrêter le serveur. Toujours à droite, vous avez l’adresse avec le port, le statut du serveur, l’utilisation de différentes ressources puis des graphiques en bas.
Concernant la partie tout en haut : – Console : Le menu sur lequel vous êtes – Files : Une gestionnaire de fichier pour le serveur – Databases : Pour gérer les bases de données liés au serveur (ne peut être utilisé avec notre installation) – Schedules : La fonctionnalité des tâches automatisés. Nous ne l’aborderons pas dans ce tutoriel. – Users : Pour ajouter des utilisateurs. Vous pourrez personnaliser leur accès (toutes les permissions sont commentés). Un peu plus bas vous sera expliqué comment créer un nouvelle utilisateur. – Backups : Pour créer des backups. – Network : Pour ajouter des ports. Ne fonctionnera pas sans ajouter un quota d’allocation lors de la création du serveur ni sans activer une option sur le panel administrateur se trouvant dans Settings > Advanced > Automatic Allocation Creation. – Startup : Permet de modifier le « docker image » et la valeur de certaines variables renseignées lors de la création du serveur. – Settings : Vous permet de changer certains éléments, et vous permet également de réinstaller le serveur. – Activity : une page de log des actions faites sur le panel en rapport avec le serveur. – La petit flèche permet d’accéder à la page en rapport avec le serveur sur le panel administrateur du panel, page qui permet de modifier à nouveau les informations précisées lors de la création du serveur.
Créer de nouveaux utilisateurs
Dans le panel administrateur (le bouton engrenage) vous avez une catégorie « Users ». Le compte que vous avez créé lors de l’installation de Pterodactyl est listé. Vous pouvez créer un nouvel utilisateur en cliquant sur Create New. Vous pourrez donc y ajouter une adresse email (mettez-en une, même invalide, cela vous permettra de l’identifier lorsque vous voudrez ajouter des accès à certains serveurs à cet utilisateur), un nom d’utilisateur, un prénom puis un nom. Default Langage est la langue par défaut que l’utilisateur aura pour le panel. C’est-à-dire qu’en remettant la main dans le cambouis, on peut ajouter des fichiers de langues, ce qui permet de changer la langue du panel. Mettre Administrator sur yes lui permettra d’accéder à l’interface administrateur du panel, ce que je vous déconseille. Pour le mot de passe, même si il est précisé que vous n’êtes pas obligé de mettre un mot de passe, dans notre cas si ! Le panel n’arrivera pas à envoyer un mail à l’adresse indiquée, qu’elle soit valide ou non.
Conclusion
Sachez qu’après avoir suivi ce tutoriel, les serveurs que vous créerez ne seront qu’accessible dans votre réseau local. Votre ami qui habite la ville d’à côté ne pourra pas y accéder, il y a d’autres manipulations à mettre en place.
Cet outil est très puissant mais requiert une certaine maitrise des systèmes linux. J’ai voulu rédiger ce tutoriel afin que vous découvriez Pterodactyl sans que vous soyez submerger par tout un paquet d’installations, de configurations, de problèmes, etc. ce qui implique de ne pas vous montrer toutes les fonctionnalités proposés par ce logiciel.
Si l’outil vous intéresse, et que vous voulez en apprendre plus ou l’utiliser sur un serveur de production, je peux déjà commencer par vous conseiller de recommencer l’installation mais en la faisant manuellement cette fois-ci, donc en suivant la documentation officielle. Sachez que le projet est très communautaire, en cas du moindre problème, vous pouvez rejoindre leur discord et poser des questions (en anglais).
Merci d’avoir lu cet article ! La principale source de cet article est le site officiel de Pterodactyl (et mes connaissances 😉).
Trouver un hébergeur de site web est une étape primordiale pour rendre votre site accessible sur Internet. Cela permet de le mettre en ligne de façon publique et permet aux visiteurs de pouvoir y accéder n’importe où et n’importe quand. En effet, un hébergeur va vous permettre de rendre votre site accessible 24h/24 ! Dans ce tutoriel, vous découvrirez comment héberger votre site, de façon totalement gratuite, grâce à CloudFlare Pages !
Cloudflare Pages, c’est quoi ?
Cloudflare est un de package de solutions pour les sites Web. Il agit autant en matière de sécurité que de performance. Néanmoins, les services de Cloudflare se diversifient de plus en plus ! Dans ce tutoriel par exemple, nous allons utiliser le service Cloudflare Pages. Cloudflare Pages va ici nous permettre de mettre en ligne notre site web. A noter que Cloudflare Pages ne supporte que les pages web HTML statique (ceci incluant les pages faites à partir de Framework JavaScript).
Héberger son site
Pour commencer, inscrivez-vous sur le site de Cloudflare. Une fois inscrit(e), vous serez automatiquement redirigé(e) vers la page d’ajout de site. Si vous n’avez pas encore de domaine, Cloudflare propose depuis peu l’enregistrement de domaine directement depuis sa plateforme. Cette étape est facultative sachant que Cloudflare Pages propose un sous-domaine gratuit (exemple.pages.dev). Une fois sur la page ci-dessous, cliquez sur l’onglet Pages du menu latéral.
Une fois sur l’onglet Pages du tableau de bord, cliquez sur Create a project afin de démarrer la procédure.
Vous aurez ici le choix entre 3 possibilités pour importer votre site web :
Importation via Git (GitHub ou GitLab)
Importation directe des fichiers du site (ZIP)
Importation via interface de ligne de commande (CLI)
Nous allons dans ce tutoriel utiliser l’importation via fichier .zip, mais la documentation du site peut vous aider à réaliser la manipulation via les autres méthodes proposées.
Avant de pouvoir téléverser les fichiers de votre site web, vous allez devoir choisir un nom pour votre projet. A noter que ce nom sera utilisé comme sous-domaine par défaut pour votre site.
Une fois avoir choisi le nom que vous souhaitez, vous pouvez dès à présent téléverser les fichiers de votre site web, via un dossier ou un fichier .zip compressé.
Les fichiers de votre site web sont désormais téléversés.
Vous pouvez dès à présent déployer votre site web !
Pour accéder à votre site, rendez-vous sur la page dont vous avez choisi le nom précédemment à travers le processus de déploiement Cloudflare Pages. Dans le cas présent, il s’agit de la page NSI42.pages.dev.
Et voilà ! Vous savez désormais comment héberger une page web gratuitement avec Cloudflare.
Pour ceux qui veulent aller plus loin, nous allons désormais apprendre à connecter notre site à un nom de domaine personnalisé !
BONUS : Mise en place d’un nom de domaine personnalisé
Pour profiter d’un nom de domaine personnalisé pour votre site, il va tout d’abord vous falloir vous en procurer un. Depuis peu, Cloudflare propose des offres d’enregistrement de noms de domaine. Une fois votre domaine enregistré et ajouté sur Cloudflare, rendez-vous sur l’onglet Custom domains depuis votre espace Cloudflare Pages.
Une fois sur l’onglet, cliquez sur sur le bouton ci-dessous.
Vous pouvez dès à présent entrer votre nom de domaine personnalisé que vous vous êtes procuré précédemment.
Une fois le nom de domaine ajouté, vous devez configurer vos enregistrements DNS afin de faire pointer celui-ci vers le sous-domaine Cloudflare de votre site. Pour se faire, recopiez la configuration suivante.
Une fois le nom de domaine ajouté, vous pourrez désormais y accéder via votre domaine personnalisé !
Et voilà ! Vous savez désormais héberger une page web gratuitement avec un nom de domaine personnalisé grâce à Cloudflare Pages.
Vous êtes un musicien solo et souhaitez créer un morceau qui sonne comme celui d’un grand groupe ? La plateforme musicale BandLab est faite pour vous ! Vous pourrez créer votre propre musique à partir de plusieurs pistes audio, y ajouter des effets sonores et même la partager avec vos abonnés ! Ne perdez plus de temps, et laissez place à votre inspiration…
Qu’est ce que BandLab ?
BandLab est une plateforme de musique gratuite créée en 2015 qui fonctionne comme un réseau social. Elle permet aux artistes de collaborer les uns avec les autres et de partager leur travail avec les auditeurs. BandLab est utilisée pour l’enregistrement ainsi que pour l’édition numérique d’enregistrements audio. Elle est accessible en se rendant sur son site Web ou en téléchargeant ses applications de bureau (MacOs et Windows) et mobiles (Android et iOS).
Premiers pas sur BandLab
Pour commencer, après avoir téléchargé l’application ou vous être rendus sur le site, il va falloir vous créer un compte.Vous pourrez y renseigner votre nom ou pseudo, votre âge et la musique que vous aimez écouter ou jouer. De plus, il existe une fonctionnalité très pratique pour insérer des liens vers vos contenus musicaux, si vous en avez, sur d’autre plateformes musicales telles Deezer ou Spotify. Il est possible de mettre votre profil en privé afin que seul vos abonnés puissent avoir accès à votre contenu.
Une fois votre compte activé, vous allez pouvoir commencer à créer votre musique. Pour cela, il vous suffit simplement d’appuyer sur le bouton « créer » se trouvant en haut à droite, puis sur « nouveau projet ».
Création de votre projet
Vous voila ensuite dans votre nouvel espace de travail !
Comme vous pourrez le constater, c’est à vous d’insérer vos pistes audios à l’endroit prévu à cet effet.
Vous pouvez enregistrer votre instrument via un enregistreur numérique ou tout simplement depuis votre téléphone portable. Ensuite, il vous suffit simplement d’appuyer sur « déposer une boucle ou un fichier audio/MIDI » puis de sélectionner votre fichier audio.
Libre à vous d’ajouter le nombre de pistes que vous souhaitez !
A présent, vous pouvez raccourcir vos pistes audio, les faire débuter à différents moments, les diviser, modifier leur volume… Toutes ces options sont réalisables pour chaque piste de façon indépendante.
Pour cela, sélectionner la piste que vous souhaitez modifier puis faites un clic droit. Vous pouvez alors choisir les différentes options pour travailler votre piste audio.
Focus sur le travail du volume :
Il est aussi possible de rectifier le volume en l’augmentant, le diminuant ou en le faisant ressortir du coté gauche ou droit de la sortie audio. Tout d’abord, sélectionner la piste concernée, puis penchez vous sur les réglages se trouvant à gauche de la piste. Pour modifier le volume, faites glisser le curseur vers la droite pour l’augmenter et vers la gauche pour le diminuer. Si vous préférez que la piste sélectionnée ressorte plus d’un côté que de l’autre, tourner le curseur (en forme de cadran) vers L (left) pour une sortie à gauche et inversement avec R (right).
Il est aussi possible de mettre une piste en mode « Solo » afin de n’écouter que cette dernière (appuyez sur le S). Au contraire, pour la mettre en « Muet » afin d’avoir un rendu sans la piste sélectionnée, appuyez sur M.
Ajout d’effets :
De plus, si l’envie vous prend, vous pouvez vous amuser à ajouter des effets sur votre piste (style classique, rap moderne, robot, reverb…) en appuyant soit sur « AutoPitch » soit sur « Effets » en bas à gauche de votre écran.
Il est aussi possible d’ajouter une autre source extérieure (voix, clap…) sur cette même piste en vous rendant sur « Source » pour l’enregistrer directement sur la piste.
Pour changer la hauteur (tonalité) ou la vitesse (tempo) d’une piste, rendez vous sur le bouton « Editeur ».
Si votre création contient des paroles, vous pouvez aussi vous rendre sur « Paroles/Notes » en bas à droite du poste de travail, afin de les ajouter. Ainsi, elles apparaitront sur votre post BandLab et défileront en même temps que la chanson.
Enfin, la touche « BandLab Sounds » qui est juste à côté permet de rajouter des boucles ou extraits de musique déjà créés par BandLab !
Pour finir, lorsque vous êtes satisfait du résultat final et souhaitez le partager, il vous suffit d’appuyer sur le bouton « Publier » en haut à droite pour que vos auditeurs y aient accès.
Il est toutefois possible d’enregistrer votre création si vous souhaitez l’améliorer à un autre moment ou simplement la garder pour vous en appuyant sur « Enregistrer », à gauche de « Publier ».
Accéder à vos projets
Une fois revenu au fil d’actualité de BandLab, il vous suffit d’appuyer sur « Bibliothèque » pour accéder à vos différents projets et sélectionner celui qui vous intéresse.
Vous pouvez alors l’ajouter à vos favoris, partager le lien sur tout autre type de réseaux sociaux, le télécharger sur votre ordinateur ou votre téléphone, le publier si cela n’est pas encore fait ou tout simplement le modifier à nouveau comme vous avez pu le faire précédemment en vous rendant sur « Studio ».
Vous voilà maintenant prêt à créer votre morceau avec BandLab, à vous de découvrir les astuces et modifications qui vous plaisent le plus…
Depuis un certain temps vous cherchez à transférer un fichier sur la clé USB d’un copain; d’une copine; d’un ou une collègue mais vous n’y arrivez pas ? Alors ne cherchez plus ! Ce tutoriel simple, efficace et précis vous aidera à résoudre ce problème, que vous soyez un expert en informatique ou un novice dans ce domaine complexe !
L’apprentissage est la seule chose que l’esprit n’épuise jamais, ne craint jamais et ne regrette jamais.
Léonard de Vinci
Mise en situation :
Si vous regardez ce tutoriel c’est normalement parce que lorsque vous tentez de déplacer un fichier sur votre clé USB, le message d’erreur affiché ci-dessous apparaît avec le titre de votre fichier à la place du mien qui se nomme donc : « film qui ne peut pas être cité pour droits d’auteur »
Pour expliquer ce message il vous suffit d’observer que la taille de votre fichier est bien supérieure à 4Go mais pour le résoudre il faudra d’abord s’intéresser aux différents systèmes de fichiers pouvant être appliqués à votre clé USB et à vos disques durs.
Les différents systèmes de fichiers d’une clé USB :
Tout d’abord, il faut savoir qu’un système de fichiers est un système de classement, d’organisation sur un support de stockage qui structure et organise l’écriture, la recherche, la lecture, le stockage, la modification et la suppression de fichiers d’une manière spécifique.
Il existe plusieurs systèmes de fichiers et nous allons vous en décrire quelques-uns.
Le FAT32 :
Le FAT32 est généralement le système de fichier formaté de base sur votre ordinateur.
Il est en service depuis plusieurs années déjà et commence à être vieillissant mais reste très performant sur plusieurs sujets.
Voici un tableau qui nous montre ses capacités, avantages et inconvénients.
Avantages
Inconvénients
– compatible avec la plupart des ports USB
– Possède un poids maximal de 4Go pour les fichiers
Le NTFS :
Le NTFS est surement le système de fichiers le plus sécurisé d’aujourd’hui.
Comme tout à l’heure voici un tableau vous résumant ses forces et faiblesses :
Avantages
Inconvénients
– Possède un poids maximal de 16To pour les fichiers – Très sécurisé -Fonctionne avec toutes les versions de Windows depuis Windows XP
– N’est pas compatible avec tout les systèmes d’exploitation ( il est compatible seulement les versions récentes de Windows mais pas avec Mac et d’autres…)
Le exFAT :
Le système de fichiers exFAT est une amélioration du système FAT32. Il comprend entre autre une extension de la taille des fichiers pouvant être utilisée.
Avantages
Inconvénients
– Possède un poids maximal de 128Po -Compatible avec la plupart des systèmes d’exploitation( Windows et Mac…)
Comment formater sa clé USB :
Comme nous l’avons vu précédemment, il existe différents systèmes de fichiers qui ont chacun leurs avantages et leurs inconvénients.
Maintenant, nous allons voir comment formater notre clé USB pour pouvoir changer de système de fichiers selon nos besoins au travers de 4 étapes :
Tout d’abord, il faudra faire un clic droit avec la souris sur la clé USB ou sur le disque dur dans » explorateur de fichiers ».
2. Ensuite, il faudra cliquer sur « formater… » :
3. Puis, il faudra cliquer sur « système de fichiers » afin de choisir celui que nous souhaitons appliquer à notre appareil :
4. Une fois notre système de fichiers sélectionné, il ne nous restera qu’à cliquer sur le bouton « démarrer » en bas de le fenêtre. A ce moment ce message doit s’afficher sur votre écran :
Nous vous conseillons donc de copier le contenu de votre clé USB ou disque dur sur le disque dur interne de l’ordinateur, ou sur un autre disque dur ou une clé USB avant d’effectuer l’opération voulue.
Ainsi, vos fichiers ne seront pas supprimés par le formatage.
Normalement, à la fin de l’opération le message ci-dessous s’affichera. Recommencez le formatage s‘il se s’affiche pas!
Conclusion :
Ainsi, afin de pouvoir transférer un fichier supérieur à 4Go, il vous faudra appliquer les consignes citées précédemment et choisir de formater au choix sa clé USB ou son disque dur en NTFS ou en exFAT.
Je vous conseille si vous êtes sur Windows d’utiliser le NTFS. Mais attention, il faudra être sûr de brancher votre disque dur ou votre clé USB sur un appareil possédant Windows depuis sa version XP.
Si vous avez un doute, le format exFAT est tout aussi pratique quoique moins sécurisé mais vous serez sûr au moins de pouvoir télécharger vos fichiers tranquillement, peu importe leurs poids, puisque comme le système de fichiers NTFS, ses limites en terme de taille maximale d’un fichier pouvant être stockées ne sont pas atteignable.
Si toutefois le problème persiste et que vous ne parvenez pas à accueillir un fichier supérieur à 4Go après l’application de ce tutoriel, je vous invite à bien vérifier que votre clé USB possède assez d’espace de stockage pour accueillir le fichier souhaité.
Si des amis ont le même problème que vous n’hésitez pas à leur parler de ce tutoriel,
Art
