Auteur : Victor E.

Tutoriels

Comment installer Linux Ubuntu sur son ordinateur, tout en…

Dans le cadre du projet « Ecrire un tutoriel en NSI« , je vous propose ce tutoriel pour apprendre simplement et efficacement comment installer correctement Linux Ubuntu sur son ordinateur tout en gardant Windows. Un tutoriel pas à pas qui aidera les plus débutants d’entre vous.

Pourquoi Installer Ubuntu ?

Premièrement, Linux est un OS/environnement de travail plus propice à une utilisation informatique poussée. Il enlève toutes les contraintes de sécurité que l’on pourrait retrouver sur Windows. Linux est bien moins gourmand en puissance de calcul que Windows, vous pourriez donc donner une seconde vie à un vieil ordinateur qui n’arrive plus à faire tourner Windows, ou bien rendre plus performant le votre. Pourquoi Ubuntu? Je conseille Ubuntu comme première version de Linux car c’est, pour moi, la distribution de Linux la plus convenable pour les premiers pas d’un(e) nouvel(le) utilisateur(trice) de Linux. Certaines distributions, comme Kali, sont compliquées à prendre en main et peuvent déstabiliser un(e) nouvel(le) utilisateur(trice).

Matérielle nécessaire :

  • Une clé vierge USB 4G minimum (possibilité de gravé un cd pour l’inhalation (fichier en .iso))
  • Disque dur / ssd avec minimum 25G de libre
  • Une connexion internet

Conseille avant de commencer :

Pour ne pas faire de mauvais manipulation ou endommagé vos appareille, je vous conseille de tester ce tuto sur un veille ordinateur, ou de faire une Back-up de votre ordinateur avant de commencé quoi que ce soit, ce maitre mon de ce tuto sera de prendre son temp.

Créer une clé USB bootable :

Télécharger Ubuntu :

Pour commencer allez sur le site officiel de Ubuntu pour téléchargé la dernier version :

Le fichier fait 3,6 Go dans sa version actuelle, il est donc normal que cela prenne un certain temps à s’installer (vous remarquerez que le fichier est en .iso, ce qui fait qu’il est possible de graver un disque pour en faire le support d’installation).

Téléchargement Rufus et son utilisation :

Rufus permet de formater et de rendre bootable n’importe quel support amovible de stockage tel que les clés USB ou les disques durs externes, et c’est cet outil que nous allons utiliser.

Commençons par téléchargé la dernier version de Rufus (ici la 3.21):

Puis lancé le .exe, accepté la demande de droit d’administrateur. La fenêtre de Rufus devrai alors souvrire et devrais ressemblé à cela :

On choisi son périphérique :

On appuie sur le bouton Sélectionner pour aller chercher le fichier de Ubuntu que l’on vient de télécharger, puis sur le bouton Démarrer. Cela va ouvrir une fenêtre où l’on laisse les paramètres par défauts et où l’on accepte avec Ok et l’on accepte encore une fois le deuxième avertissement qui nous indique que la clé USB va être formatée. Une fois cela fait, cela risque de prendre un peu de temps en fonction de votre ordinateur. Il suffit juste d’attendre la fin du chargement.

Une fois la conversion réaliser cliquez simplement sur Fermer, et c’est finit, vous venez de réalisé une clé USB bootable fonctionnelle !!!

Créer une partition dans son disque pour installer Ubuntu :

Avant de commencé quoi que ce soit sachez que cette étape peux être optionnelle si vous possédée deux disque dans votre ordinateur et que vous décidé d’utilisé l’entièreté de l’un de ces deux disque pour installer Ubuntu.

Premièrement regardez si il vous reste de l’espace disponible dans votre disque et si cette espace restant n’est essentielle. Puis allez dans la barre de recherche Windows et tapez « Partitions » et cliqué sur l’outil l’outils « Créer et formaté des partitions de disque dur« , une fois ouvert une nouvel fenêtre devrais s’ouvrir vous permettant de voir vo(s) disque(s) :

Fait clic droit sur le disque ou vous souhaitez installer Ubuntu et cliquer sur Réduire le volume ... cela vas alors calculé l’espace de stockage que Windows peut vous libéré pour faire votre installation.

Ici on me propose un espace de 69 Go mais je n’aurais besoin que de 40 Go soit 40.000 Mo, j’indique donc la valeur dans « Quantité d’espace à réduire » et j’appuis sur réduire :

On vois bien qu’est espace  à 40 Go à été libéré.

Installation et configuration de Ubuntu :

Démarre son ordinateur sur la clé USB bootable :

Premièrement braché votre clés USB à votre ordinateur. Nous arrivons maintenant sur une étape délicate ou je ne vais pas pouvoir vous guider plus que cela. l’idée pour démarré sur la clé USB est d’allé dans le Bios pour ouvrir la clé USB dans le Boots menu, il vas donc falloir ouvrir la Bios, l’ouverture du Bios est spécifique au modèle de carte mère de chaque ordinateur, pour savoir exactement comment faire, je vous conseille de regarder le guide de votre carte mère pour voir, ou bien celui de la référence de votre ordinateur pour l’ouvrir. la plus part du temp il surfil simplement de matraqua les touches F2, ou DEL l’ors de l’allumage du l’ordinateur, mais cela ne marche pas forcément est surtout ut les les ordinateur portables (fast boute empêche les raccourcis habituelle pour ceux qui connaissent), je vous propose donc cette petit vidéo pour tout les personnes qui pourrais avoir du mal.

Une fois le Bios ouvert la aussi tout vas dépendre de votre ordinateur et de ça carte mère, il y a des bios avec des interface plus ou moins graphique , pour autant le but va être d’accédé au Boot menu, puis de choisir votre clé USB qui contiens Ubuntu pour démarré dessue pour que l’installation commence, je vous met si dessous quelques screen shot d’a quoi à ressemblé mon installation :

Ouverture du Bios
ici j’ai échanger USB DISK 3.0 et Windows Boot manager ce qui fait que l’ordinateur démarrera sur la clé USB
Fermeture en enregistrement des modifications

Une fois les étapes présidentes réalisé, le Grub devrais s’ouvrir vous laissant le choix entre plusieurs lancement, vous allez choisir Try or Install Ubuntu.

Une fois cela fait un écran de chargement devrais ce lancé vous laissant apparaitre le logo de Ubuntu

Installation et Paramétrage de Ubuntu :

Bravo ! Si vous êtes à cette étapes c’est que vous avez passé la premier parti difficile de cette installation. Nous allons donc maintenant installé définitivement Ubuntu et le configure correctement.

Premièrement choisissez votre langue puis cliqué sur Install Ubuntu, ensuite choisissez quel types de configuration de clavier vous voulez (Frenche-French(legacy, alt.)), n’hésitez pas à testé toutes vos touches et tout les symboles pour vérifier que tout fonctionne correctement, puis connecté vous à votre Wi-Fi.

Nous arrivons au premier écran « important », cela vas concerné la case à cocher « Installer un logiciel pour le matériel graphique et Wi-Fi et des formats de média supplémentaire« , cela vas permettre à Ubuntu d’accepté d’installé des logicielle auquel il n’a pas acquêt, comme les pilot de carte graphique (les pilots de NVidia, qui sont des pilots propriétaires ) ou des pilots de cartes Wi-Fi. Une fois cette case cocher configure le mot de passe pour le sécure Boot ( vous n’y aurais pas recours fréquemment, voir jamais, je vous conseille de mettre le même mot de passe que celui de votre ordinateur), une fois cela fait cliqué sur « continuer »

Et nous arrivons sur l’écran LE PLUS IMPORTANT :

Ici l’on vas choisir entre une installation manuel ou automatique de Ubuntu, pour terminé rapidement, mais je ne conseille pas cette solution, pour continuer cliqué sur « Autre chose » puis continuer pour arrive à l’écran de paramétrage finale:

Premièrement regardons en fonction de l’espace disponible quelle espace faut-il alloué à chaque partie, pour cela regarde cette feuille de calcule pour comparé.

Dans l’espace libre, il vas falloir crée trois partition distincte, le Root (/), le Swap, et la Home (/home), pour cela faite un clic droit sur l’espace libre et cliqué sur « Ajouter… », une fois la fenêtre ouverte met dans point de montage un « / » et donne on fonction de l’espace souhaiter, puis refaire la même chose sauf que cette fois ici cliqué sur utilisé comme et allez chercher « espace d’échange (swap) » mettre l’espace nécessaire en fonction du tableur refaire encor une fois la manipulation, et mettre « /home » dans le point de montage.

C’est bon, vous venez de terminé la partie la plus compliqué » de l’installation de Ubuntu sur votre ordinateur, si tout c' »est bien passé vos partition devrai ressemblé à cela :

Et il ne vous reste plus continuer après les avertissement, choisir son fuseaux horaire, complété sont profile, et attendre la fin de l’installation de Ubuntu, une fois terminé, il est demander redémarré l’ordinateur et l’ors du redémarrage, quand il l’ai demander, retiré la clé USB et appuyer sur ENTER.

Choisir si l’ont démarre sur Windows ou sur Ubuntu :

Maintenant que vous avec Ubuntu sur votre ordinateur, vous souhaiter certainement retourné sur Windows pour s’assuré que tout c’est bien passé, pour cela redémarré l’ordinateur, et attendez d’arriver sur le Grub, une fois dessus avec les flèches directionnelle sélectionner « *Windows Boot Manager (on/dev/sdb1) » pour démarré sur Windows.

Merci d’avoir suivit ce tutoriel, j’espère qu’il vous aura aidez et qu’il vous aura permit de vous introduire un monde de Linux. Sur ceux que vous souhaite une bonne découverte !!!

Art

Perspective : un paysage Synthwave

Dans le cadre de la 5ème édition du dispositif “Regards de Géomètre”, nous avons décidé dans le thème « Perspective » de produire un paysage synthwave.

Vidéo du projet

Origines de la Synthwave

Avant tout la synthwave est un genre musical électronique ayant émergé dans les années 2000/2010 qui s’inspire d’éléments des années 80. Et c’est justement dans les clips de ces musiques que l’on va retrouver ce type d’image.

Pour en savoir plus nous vous conseillons cette vidéo qui explique brièvement les origines.

Le Projet

Revenons donc au projet. Pour ce projet nous avons donc décidé de produire une image d’un paysage synthwave. Pour cela nous utilisons le module turtle ainsi que le module random, le module turtle est utilisé pour produire l’image est le module random est utilisé pour les étoiles de l’image où la taille et leur position est générée aléatoirement nous avons également utilisé le script permettant d’exporter une image générée par turtle en .png que vous pouvez retrouver ici.

Structure du script

Pour la structure du script nous avons décidé de découper chaque partie de l’image (pavage, fond, étoiles, soleil, ville et montagnes) afin de créer des fonctions et à la fin nous les avons toutes appelées dans un ordre précis pour que les différentes parties de l’image soit dans leur plan respectif.

Analyse du script

Nous allons donc analyser le script.

Commençons par l’appel des modules et la mise en place de turtle.

from turtle import *
from random import randint
# vérification des modules importés
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
titre = "Perspective - Un paysage Synthwave"
title(titre+" | Au lycée, la meilleure spécialité, c'est la spé NSI")
setup(1280, 720) # définit la taille de la fenêtre
colormode(255) # permet l'utilisation de couleurs rgb
speed(0) #Remplaçable par tracer(2) (10x plus rapide) mais si il est utilisé des lignes du pavage peuvent manquer
hideturtle() #dissimule la tortue

On appelle les fonctions turtle, random avec pour random uniquement randint et on utilise une partie du script « exporter une image générée par turtle » pour vérifier que l’utilisateur a bien installé le module PIL et dans le cas contraire un message d’erreur s’affichera et lui donnera un lien pour installer le module et tout ça sans que le script ne s’arrête. Après la vérification on met en place le titre de la fenêtre qui va affiché le rendu ainsi que sa taille. Enfin on définit le type de couleurs utilisées (R,G,B), la vitesse de la tortue, et on dissimule la tortue (c’est plus joli).

Commençons par la première fonction : le fond

def fond():
    penup()
    rciel = 0
    gciel = 0 
    bciel = 0
    hauteur = -360
    goto(-642,-358)
    pendown()
    while hauteur != 360:
        pencolor(round(239 + rciel), round(41 + gciel), round(209 + bciel))
        forward(1280)
        hauteur += 1
        goto(-640, hauteur)
        rciel += (-29/180)
        gciel += (2/45)
        bciel += (7/720)

Pour le fond on aurait pu utiliser une fonction qui crée un rectangle et qui le remplit avec fill_rect, cependant la couleur dans ce cas est uni ce qui ne nous intéresse pas. Nous avons donc produit un script qui fait un fond dégradé qui fait avancer la tortue sur une ligne d’un pixel de large et à la fin de cette ligne la tortue est envoyé grâce à un goto à la ligne d’après et qui ajoute la différence de chaque couleur (rouge,vert et bleu) entre la couleur de début du dégradé et la couleur de fin. Tout ceci est arrondi car turtle n’est pas compatible avec des arguments à virgule (pour la fonction pencolor en tout cas).

Par la suite la fonction qui produit les étoiles a été codée :

def etoile():
    for i in range(90):
        penup()
        goto(randint(-720,720), randint(0,360))
        pendown()
        pencolor(255, 255, 255)
        lcercle = randint(1,3)
        fillcolor('white')
        begin_fill()
        circle(lcercle)
        end_fill()

Pour les étoiles on définit aléatoirement leur position sur la moitié haute de l’image, on les met en blanc, on définit aussi aléatoirement la taille de l’étoile et on créer l’étoile avec sa position, et sa taille en aléatoire puis on refait ce processus 90 fois pour avoir 90 étoiles.

Ensuite nous avons le soleil (Le script affiché n’est qu’une petite partie du script total du soleil car il est très long et qu’il se répète, il est donc inutile de commenter la suite) :

def soleil():
    penup()
    liste1 = [10,7,5,4,3,3,3,3,2,2,2,2,2,2,2,1,2,1,2,1,1,2,1,1,1,1,2,1,1,1]
    liste2 = [1,1,1,0,1,1,1,1,1,0,1,1,1,0,1,1,0,1,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0]
    pliste1 = 0
    pliste2 = 0
    rsoleil = 0
    gsoleil = 0
    bsoleil = 0
    lsoleil = 8
    hauteur = 30
    goto(0,30)
    pendown()
    for i in range(15):
        pencolor(round(255 + rsoleil), round(23 + gsoleil), round(226 + bsoleil))
        forward(lsoleil)
        backward(2*lsoleil)
        hauteur += 1
        lsoleil += liste1[pliste1]
        pliste1 += 1
        goto(0, hauteur)
        rsoleil += (0)
        gsoleil += (114/101)
        bsoleil += (-203/202)
    forward(lsoleil)
    backward(2*lsoleil)
    penup()

Pour le soleil nous réutilisons le script du dégradé, cependant nous l’avons modifier pour que le point d’origine de la tortue soit au centre du rectangle et que la longueur de chaque ligne soit défini par une liste (ce qui permet de faire un cercle en prenant les longueur d’un cercle utilisable en pixel art). Pour ce qui est des endroits ou le soleil est coupé la tortue fait le tracé mais on a utilisé la fonction penup() qui fait que la tortue ne dessine plus.

Après nous avons la fonctions des montagnes (Encore une fois le script n’est pas complet car il se répète encore 3 fois après.) :

def montagne():
    #montagne derrière la première
    penup()
    goto(-480,0)
    fillcolor(110, 27, 188)
    begin_fill()
    for i in range(3):
        forward(250)
        left(120)
    end_fill()
    
    goto(-480,0)
    pencolor(51, 210, 246)
    ymontagne = 10
    for i in range(11):
        pendown()
        goto(-355,ymontagne)
        goto(-230,0)
        penup()
        goto(-480,0)
        ymontagne += 20

Pour le script des montagnes nous avons utilisé le script pour faire des triangles équilatéraux retrouvable ici. Et ensuite nous avons utilisé un ‘for i in range’ pour faire des goto enchaîné pour faire les lignes des montagnes.

Ensuite nous avons les fonctions de la ville. Pourquoi les fonctions car il y a une fonction pour chaque bâtiment différent ainsi qu’une fonction finale qui définit l’ordre des bâtiments.

def bat1():
    penup()
    rbat = 0
    gbat = 0 
    bbat = 0
    hauteur = 0
    pendown()
    xturtle, yturtle = pos()
    while hauteur != 72:
        pencolor(round(125 + rbat), round(35 + gbat), round(216 + bbat))
        forward(42)
        hauteur += 1
        goto(xturtle, hauteur)
        rbat += (-5/3)
        gbat += (-7/15)
        bbat += (-72/25)
    forward(42)
    penup()
    right(90)
    forward(72)
    left(90)

Pour le bâtiment 1 il y a un dégradé (toujours le même script) puis on fait que la tortue finisse le bâtiment en bas à droite de ce dernier pour pouvoir enchainer les bâtiments.

fun fact : Au début nous n’avions pas prévu les quelques lignes à la fin pour que la tortue puisse enchaîner les bâtiments sans que les fonctions des bâtiments aient besoin d’être modifiés ce qui nous a amené à avoir tous les bâtiments qui se chevauchaient.

def ville():
    penup()
    goto(-320,0)
    bat3(), bat2(), bat1(), bat4() ,bat3(), bat4(), bat3(), bat2(), bat1(), bat2(), bat1(), bat3(), bat1(), bat4(), bat2(), bat1(), bat3(), bat1(), bat4(), bat3()

Et à la fin on a fait la fonction ville qui appelle dans l’ordre choisi les bâtiments. Le goto permet de définir où commence le premier bâtiment, les autres se mettent juste après le premier sans se chevaucher ni laisser un espace.

Par la suite nous avons le pavage (très long aussi, il sera donc coupé) :

def pavage():
    colormode(255)
    pensize(5)
    speed(0)
    rciel = 0
    gciel = 0 
    bciel = 0
    hauteur = -360
    penup()
    goto(-640,-360)
    pendown()
    while hauteur != 0:
        pencolor(round(15 + rciel), round(4 + gciel), round(76 + bciel))
        forward(1280)
        hauteur += 1
        goto(-640, hauteur)
        rciel += (91/180)
        gciel += (1/36)
        bciel += (7/18)

Pour le début du pavage on retrouve encore le script du dégradé mais avec les couleurs modifiées.

pencolor(229, 123, 240)
    #Lignes au dessus du pavage
    pensize(4),penup(),goto(-640,0),pendown(),goto(640,0),pensize(2),penup(),goto(-640, 0),pendown()
    #lignes gauche
    penup(),goto(-20.00,0),pendown(),goto(-60.00,-360.00),penup(),goto(-60.00,0),pendown(),goto(-180.00,-360.00),penup(),goto(-100.00,0),pendown(),goto(-300.00,-360.00),penup(),goto(-140.00,0),pendown(),goto(-420.00,-360.00),penup(),goto(-180.00,0),pendown(),goto(-540.00,-360.00),penup(),goto(-220.00,0),pendown(),goto(-660.00,-360.00),penup(),goto(-260.00,0),pendown(),goto(-780.00,-360.00),penup(),goto(-300.00,0),pendown(),goto(-900.00,-360.00),penup(),goto(-340.00,0),pendown(),goto(-1020.00,-360.00),penup(),goto(-380.00,0),pendown(),goto(-1140.00,-360.00),penup(),goto(-420.00,0),pendown(),goto(-1260.00,-360.00),penup(),goto(-460.00,0),pendown(),goto(-1380.00,-360.00),penup(),goto(-500.00,0),pendown(),goto(-1500.00,-360.00),penup(),goto(-540.00,0),pendown(),goto(-1620.00,-360.00),penup(),goto(-580.00,0),pendown(),goto(-1740.00,-360.00),penup(),goto(-620.00,0),pendown(),goto(-1760.00,-360.00)
    #lignes droites
    penup(),goto(20,0),pendown(),goto(60.00,-360.00),penup(),goto(60.00,0),pendown(),goto(180.00,-360.00),penup(),goto(100.00,0),pendown(),goto(300.00,-360.00),penup(),goto(140.00,0),pendown(),goto(420.00,-360.00),penup(),goto(180.00,0),pendown(),goto(540.00,-360.00),penup(),goto(220.00,0),pendown(),goto(660.00,-360.00),penup(),goto(260.00,0),pendown(),goto(780.00,-360.00),penup(),goto(300.00,0),pendown(),goto(900.00,-360.00),penup(),goto(340.00,0),pendown(),goto(1020.00,-360.00),penup(),goto(380.00,0),pendown(),goto(1140.00,-360.00),penup(),goto(420.00,0),pendown(),goto(1260.00,-360.00),penup(),goto(460.00,0),pendown(),goto(1380.00,-360.00),penup(),goto(500.00,0),pendown(),goto(1500.00,-360.00),penup(),goto(540.00,0),pendown(),goto(1620.00,-360.00),penup(),goto(580.00,0),pendown(),goto(1740.00,-360.00),penup(),goto(620.00,0),pendown(),goto(1760.00,-360.00)
    #Lignes horizontales
    penup(),goto(-640, -300),pendown(),goto(640, -300),penup(),goto(-640, -240),pendown(),goto(640, -240),penup(),goto(-640, -190),pendown(),goto(640, -190),penup(),goto(-640, -140),pendown(),goto(640, -140),penup(),goto(-640, -100),pendown(),goto(640, -100),penup(),goto(-640, -70),pendown(),goto(640, -70),penup(),goto(-640, -40),pendown(),goto(640, -40),penup(),goto(-640, -15),pendown(),goto(640, -15),

On a par la suite énormément de goto afin de faire le quadrillage du pavage.

Pour produire l’image finale nous avons les appels des différents fonctions à la fin :

#appel de toutes les fonctions
fond(), etoile(), soleil(), montagne(), ville(), pavage()

Et pour exporter l’image finale en .png il y a la suite du script pour exporter une image générée par turtle en .png utilisé au début du script.

#enregistrement de l'image finale avec vérification des modules importés
image = getcanvas()
nom_du_fichier_sans_extension=titre+"_"+hex(randint(2**30+2**25,2**30+2**25+2**24-1))[2:]
image.postscript(file=nom_du_fichier_sans_extension+".ps", colormode='color')
try:
    psimage = Image.open(nom_du_fichier_sans_extension+".ps")
    psimage.load(scale=2)
    psimage_resized = psimage.resize((1280, 720))
    psimage.save(nom_du_fichier_sans_extension+".png")
    print(nom_du_fichier_sans_extension+".png", psimage.size, "sauvegardé dans le dossier")    
except:
    if not pillow_installed:
        print("Oops! - ModuleNotFoundError: No module named 'PIL' - RTFM :")
        print("https://nsi.xyz/py2png")
    else:
        print("Oops! - 'ghostscript' not installed- RTFM :")
        print("https://nsi.xyz/py2png")
exitonclick()

Le script va donc générer une image en .ps et la convertir en .png avec un nom généré aléatoirement pour éviter que à chaque fois que vous générez une image l’image soit écrasée

Télécharger le .py

L’image finale