{"id":3583,"date":"2026-07-07T16:11:02","date_gmt":"2026-07-07T14:11:02","guid":{"rendered":"https:\/\/rootmail.it\/courses\/lpic-1-exam-101-010-160-corso-completo-in-italiano\/lessons\/101-2-avviare-il-sistema\/"},"modified":"2026-07-20T21:55:01","modified_gmt":"2026-07-20T19:55:01","slug":"101-2-avviare-il-sistema","status":"publish","type":"lesson","link":"https:\/\/rootmail.it\/en\/courses\/lpic-1-exam-1-101-500-corso-completo-in-italiano\/lessons\/101-2-avviare-il-sistema\/","title":{"rendered":"101.2 Avviare il sistema"},"content":{"rendered":"

101.2 Avviare il sistema<\/h2>\n

L’avvio di un sistema Linux \u00e8 un processo composto da diverse fasi, durante le quali firmware, bootloader, kernel e sistema di inizializzazione collaborano per rendere il computer operativo. Comprendere il funzionamento del processo di boot \u00e8 una competenza fondamentale per qualsiasi amministratore di sistema. Molti problemi di avvio possono infatti essere individuati e risolti solo conoscendo cosa accade nelle varie fasi dell’inizializzazione del sistema. In questa lezione analizzerai l’intero processo di avvio di Linux, partendo dall’accensione del computer fino al caricamento dei servizi di sistema e alla presentazione della schermata di login.<\/p>\n

\n

\ud83d\udca1 Exam Tip<\/strong> Il processo di boot \u00e8 uno degli argomenti pi\u00f9 importanti dell’esame LPIC-1 Exam 101. \u00c8 fondamentale conoscere il ruolo di BIOS\/UEFI, bootloader, kernel, initramfs e systemd, oltre alla corretta sequenza delle fasi di avvio.<\/p>\n<\/blockquote>\n

\n

\ud83c\udfaf Obiettivi della lezione<\/h2>\n

Al termine di questa lezione sarai in grado di:<\/p>\n

    \n
  • comprendere le principali fasi del processo di avvio di un sistema Linux;<\/li>\n
  • distinguere il ruolo di BIOS e UEFI durante il boot;<\/li>\n
  • comprendere il funzionamento del bootloader GRUB 2;<\/li>\n
  • descrivere il caricamento del kernel Linux e dell’initramfs;<\/li>\n
  • comprendere il ruolo di systemd durante l’inizializzazione del sistema;<\/li>\n
  • identificare le principali cause dei problemi di avvio.<\/li>\n<\/ul>\n
    \n

    Argomenti trattati<\/h2>\n
      \n
    • Bootloader e parametri del kernel.<\/li>\n
    • Firmware BIOS e UEFI.<\/li>\n
    • Bootloader GRUB 2.<\/li>\n
    • Kernel Linux.<\/li>\n
    • Initramfs.<\/li>\n
    • Systemd e processo di inizializzazione.<\/li>\n
    • Sequenza completa del boot.<\/li>\n<\/ul>\n
      \n

      101.2.1 Bootloader e parametri del kernel<\/h2>\n

      Quando un computer viene acceso, il firmware (BIOS<\/strong> o UEFI<\/strong>) inizializza l’hardware e individua il dispositivo dal quale avviare il sistema operativo. A questo punto entra in funzione il bootloader<\/strong>, un componente fondamentale del processo di avvio. Il bootloader \u00e8 un piccolo programma il cui compito principale \u00e8 caricare il kernel Linux nella memoria RAM<\/strong> e trasferirgli il controllo del sistema. Senza un bootloader il sistema operativo non potrebbe essere eseguito, poich\u00e9 il firmware non \u00e8 in grado di caricare direttamente il kernel. Oltre ad avviare Linux, il bootloader permette di scegliere quale sistema operativo eseguire, quale versione del kernel utilizzare e quali parametri passare al kernel durante il boot.<\/p>\n

      \n

      \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 fondamentale conoscere il ruolo del bootloader. Ricorda che il suo compito principale \u00e8 caricare il kernel Linux in memoria e avviarne l’esecuzione.<\/p>\n<\/blockquote>\n

      \n

      Cos’\u00e8 un bootloader?<\/h3>\n

      Un bootloader<\/strong> \u00e8 un programma di piccole dimensioni che viene eseguito immediatamente dopo il firmware BIOS o UEFI. Le sue principali responsabilit\u00e0 sono:<\/p>\n

        \n
      • individuare il kernel Linux sul disco;<\/li>\n
      • caricare il kernel nella memoria RAM;<\/li>\n
      • caricare l’initramfs<\/strong> (Initial RAM Filesystem), se presente;<\/li>\n
      • passare al kernel eventuali parametri di avvio;<\/li>\n
      • trasferire il controllo al kernel affinch\u00e9 continui il processo di inizializzazione del sistema.<\/li>\n<\/ul>\n

        Nei sistemi configurati in dual boot<\/strong> o multi boot<\/strong>, il bootloader consente inoltre di scegliere quale sistema operativo avviare.<\/p>\n

        \n

        I principali bootloader Linux<\/h3>\n

        Nel corso degli anni Linux ha utilizzato diversi bootloader. I pi\u00f9 conosciuti sono:<\/p>\n\n\n\n\n\n\n
        Bootloader<\/th>\nDescrizione<\/th>\n<\/tr>\n<\/thead>\n
        GRUB 2 (GRand Unified Bootloader)<\/strong><\/td>\nBootloader utilizzato dalla maggior parte delle distribuzioni Linux moderne.<\/td>\n<\/tr>\n
        LILO (Linux Loader)<\/strong><\/td>\nStorico bootloader ormai quasi completamente sostituito da GRUB 2.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

        Attualmente GRUB 2<\/strong> rappresenta lo standard adottato dalle principali distribuzioni Linux, tra cui Ubuntu, Debian, Fedora, openSUSE e molte altre.<\/p>\n

        \n

        \ud83d\udccc Da ricordare<\/strong> Sebbene LILO possa ancora comparire in alcune domande d’esame, nella pratica quasi tutti i sistemi Linux moderni utilizzano GRUB 2<\/strong>.<\/p>\n<\/blockquote>\n

        \n

        Il menu di GRUB<\/h3>\n

        Durante l’avvio del computer, GRUB visualizza normalmente un menu che permette di scegliere come avviare il sistema. Tra le opzioni pi\u00f9 comuni troviamo:<\/p>\n

          \n
        • avvio normale di Linux;<\/li>\n
        • selezione di una diversa versione del kernel;<\/li>\n
        • modalit\u00e0 di ripristino (Recovery Mode);<\/li>\n
        • altri sistemi operativi installati (ad esempio Microsoft Windows).<\/li>\n<\/ul>\n

          Un esempio semplificato del menu di GRUB \u00e8 il seguente:<\/p>\n

          GNU GRUB\r\n\r\n> Ubuntu\r\n  Ubuntu (Advanced options)\r\n  Windows Boot Manager<\/code><\/pre>\n
          Se sul computer \u00e8 installata una sola distribuzione Linux, il menu potrebbe non essere visualizzato e il sistema verr\u00e0 avviato automaticamente dopo alcuni secondi.<\/p>\n
          \n
          Parametri del kernel<\/h3>\n
          I parametri del kernel<\/strong> sono opzioni che il bootloader passa al kernel Linux durante il processo di avvio. Essi consentono di modificare il comportamento del sistema prima ancora che venga completata l’inizializzazione di Linux. Gli amministratori di sistema li utilizzano frequentemente per attivit\u00e0 di manutenzione, diagnostica e risoluzione dei problemi. Alcuni parametri comuni sono:<\/p>\n\n\n\n\n\n\n\n\n
          Parametro<\/th>\nDescrizione<\/th>\n<\/tr>\n<\/thead>\n
          quiet<\/code><\/td>\nRiduce i messaggi visualizzati durante il boot.<\/td>\n<\/tr>\n
          splash<\/code><\/td>\nVisualizza una schermata grafica durante l’avvio del sistema.<\/td>\n<\/tr>\n
          single<\/code><\/td>\nAvvia il sistema in modalit\u00e0 utente singolo (single-user mode).<\/td>\n<\/tr>\n
          nomodeset<\/code><\/td>\nDisabilita temporaneamente il Kernel Mode Setting, utile per risolvere alcuni problemi video.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
          \n
          Modificare temporaneamente i parametri di avvio<\/h3>\n
          GRUB permette di modificare temporaneamente i parametri del kernel prima dell’avvio del sistema. Per farlo \u00e8 sufficiente:<\/p>\n
            \n
          1. selezionare la voce desiderata nel menu di GRUB;<\/li>\n
          2. premere il tasto e<\/strong> (Edit<\/em>);<\/li>\n
          3. individuare la riga che inizia con linux<\/code>;<\/li>\n
          4. aggiungere i parametri desiderati al termine della riga;<\/li>\n
          5. premere Ctrl + X<\/strong> oppure F10<\/strong> per avviare il sistema.<\/li>\n<\/ol>\n
            Ad esempio:<\/p>\n
            linux \/boot\/vmlinuz-6.8.0 root=\/dev\/sda2 ro quiet splash single<\/code><\/pre>\n
            In questo caso viene aggiunto il parametro single<\/code>, che avvia il sistema in modalit\u00e0 utente singolo.<\/p>\n
            \n
            \u26a0\ufe0f Errore comune<\/strong> Le modifiche effettuate premendo e<\/strong> nel menu di GRUB sono temporanee<\/strong>. Hanno effetto solo per l’avvio corrente e non modificano in modo permanente la configurazione del bootloader.<\/p>\n<\/blockquote>\n
            \n
            Best Practice<\/h3>\n
            Prima di rendere permanente un nuovo parametro del kernel, \u00e8 consigliabile provarlo temporaneamente dal menu di GRUB. Se il sistema si avvia correttamente, sar\u00e0 possibile applicare la modifica in modo definitivo aggiornando la configurazione del bootloader.<\/p>\n
            \n
            Riepilogo<\/h3>\n
              \n
            • Il bootloader viene eseguito subito dopo BIOS o UEFI.<\/li>\n
            • Il suo compito principale \u00e8 caricare il kernel Linux nella memoria RAM.<\/li>\n
            • GRUB 2 \u00e8 il bootloader utilizzato dalla maggior parte delle distribuzioni Linux moderne.<\/li>\n
            • Dal menu di GRUB \u00e8 possibile scegliere il sistema operativo o una diversa versione del kernel.<\/li>\n
            • I parametri del kernel consentono di modificare il comportamento del sistema durante il boot.<\/li>\n
            • Le modifiche effettuate dal menu di GRUB sono temporanee e valgono solo per l’avvio corrente.<\/li>\n<\/ul>\n
              101.2.2 Panoramica della sequenza di avvio<\/h2>\n
              L’avvio di un sistema Linux \u00e8 composto da una serie di fasi che vengono eseguite sempre nello stesso ordine. Ogni componente ha un compito ben preciso e, al termine del proprio lavoro, trasferisce il controllo al componente successivo.<\/p>\n
              Comprendere questa sequenza \u00e8 fondamentale per diagnosticare eventuali problemi di avvio e per capire il ruolo dei vari componenti che partecipano al processo di boot.<\/p>\n
              \n
              \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 importante conoscere l’ordine corretto delle fasi del boot. Una domanda tipica consiste nel riordinare correttamente BIOS\/UEFI, bootloader, kernel, initramfs e sistema di inizializzazione.<\/p>\n<\/blockquote>\n
              \n
              Sequenza completa del boot<\/h3>\n
              Il processo di avvio pu\u00f2 essere riassunto nel seguente schema:<\/p>\n
              Accensione del computer\r\n        \u2502\r\n        \u25bc\r\nBIOS \/ UEFI\r\n        \u2502\r\n        \u25bc\r\nBootloader (GRUB 2)\r\n        \u2502\r\n        \u25bc\r\nKernel Linux\r\n        \u2502\r\n        \u25bc\r\ninitramfs\r\n        \u2502\r\n        \u25bc\r\nFilesystem root\r\n        \u2502\r\n        \u25bc\r\nsystemd (PID 1)\r\n        \u2502\r\n        \u25bc\r\nServizi di sistema\r\n        \u2502\r\n        \u25bc\r\nSchermata di login<\/code><\/pre>\n
              Ogni fase prepara quella successiva fino a rendere il sistema completamente operativo.<\/p>\n
              \n
              1. Accensione del computer<\/h3>\n
              Il processo di boot inizia nel momento in cui il computer viene acceso.<\/p>\n
              La CPU esegue immediatamente il codice contenuto nel firmware della scheda madre, che pu\u00f2 essere:<\/p>\n
                \n
              • BIOS (Basic Input\/Output System)<\/strong>, presente nei sistemi meno recenti;<\/li>\n
              • UEFI (Unified Extensible Firmware Interface)<\/strong>, utilizzato dalla quasi totalit\u00e0 dei computer moderni.<\/li>\n<\/ul>\n
                Lo scopo di questa fase \u00e8 inizializzare l’hardware e verificare che il sistema sia pronto per l’avvio.<\/p>\n
                \n
                2. BIOS o UEFI<\/h3>\n
                Il firmware esegue il Power-On Self Test (POST)<\/strong>, una serie di controlli diagnostici che verificano il corretto funzionamento dei principali componenti hardware.<\/p>\n
                Tra gli elementi controllati troviamo:<\/p>\n
                  \n
                • processore (CPU);<\/li>\n
                • memoria RAM;<\/li>\n
                • controller dei dischi;<\/li>\n
                • tastiera;<\/li>\n
                • periferiche essenziali.<\/li>\n<\/ul>\n
                  Terminata questa fase, BIOS o UEFI cercano un dispositivo avviabile (boot device), ad esempio un SSD, un hard disk o una chiavetta USB.<\/p>\n
                  Una volta individuato il dispositivo corretto, il firmware carica il bootloader e gli trasferisce il controllo.<\/p>\n
                  \n
                  3. Bootloader<\/h3>\n
                  Il bootloader (generalmente GRUB 2<\/strong>) rappresenta il collegamento tra il firmware e il sistema operativo.<\/p>\n
                  Le sue principali funzioni sono:<\/p>\n
                    \n
                  • mostrare il menu di avvio;<\/li>\n
                  • consentire la scelta del sistema operativo;<\/li>\n
                  • caricare il kernel Linux;<\/li>\n
                  • caricare l’initramfs;<\/li>\n
                  • passare eventuali parametri di avvio al kernel.<\/li>\n<\/ul>\n
                    Dopo aver completato queste operazioni, il bootloader cede il controllo al kernel Linux.<\/p>\n
                    \n
                    4. Kernel Linux<\/h3>\n
                    Il kernel \u00e8 il cuore del sistema operativo.<\/p>\n
                    Durante le prime fasi dell’avvio provvede a:<\/p>\n
                      \n
                    • inizializzare la memoria;<\/li>\n
                    • configurare la CPU;<\/li>\n
                    • inizializzare i driver integrati;<\/li>\n
                    • rilevare i dispositivi hardware;<\/li>\n
                    • decomprimere ed eseguire l’initramfs.<\/li>\n<\/ul>\n
                      In questa fase il sistema non \u00e8 ancora completamente operativo, poich\u00e9 il filesystem principale non \u00e8 stato ancora montato.<\/p>\n
                      \n
                      5. Initramfs<\/h3>\n
                      L’initramfs (Initial RAM Filesystem)<\/strong> \u00e8 un piccolo filesystem temporaneo caricato interamente nella memoria RAM.<\/p>\n
                      Contiene i driver e gli strumenti necessari affinch\u00e9 il kernel possa individuare e montare il filesystem root del sistema.<\/p>\n
                      Una volta montato il filesystem principale, l’initramfs termina il proprio lavoro e trasferisce il controllo al sistema di inizializzazione.<\/p>\n
                      \n
                      \ud83d\udccc Da ricordare<\/strong> L’initramfs \u00e8 un filesystem temporaneo. Viene utilizzato esclusivamente durante il processo di boot e non coincide con il filesystem root definitivo del sistema.<\/p>\n<\/blockquote>\n
                      \n
                      6. Sistema di inizializzazione<\/h3>\n
                      Dopo il montaggio del filesystem principale, il kernel avvia il primo processo dello spazio utente, chiamato init<\/strong>.<\/p>\n
                      Nei sistemi Linux moderni questo ruolo \u00e8 svolto quasi sempre da systemd<\/strong>, mentre nei sistemi pi\u00f9 datati pu\u00f2 essere presente SysVinit<\/strong>.<\/p>\n
                      Il sistema di inizializzazione ha il compito di:<\/p>\n
                        \n
                      • avviare i servizi di sistema;<\/li>\n
                      • configurare la rete;<\/li>\n
                      • montare gli altri filesystem;<\/li>\n
                      • avviare i demoni necessari;<\/li>\n
                      • presentare la schermata di login.<\/li>\n<\/ul>\n
                        Il primo processo eseguito nello spazio utente possiede sempre il PID 1<\/strong>, un dettaglio frequentemente richiesto negli esami LPIC.<\/p>\n
                        \n
                        \ud83d\udca1 Exam Tip<\/strong> Il processo con PID 1<\/strong> \u00e8 il sistema di inizializzazione. Nei sistemi Linux moderni \u00e8 generalmente systemd<\/strong>.<\/p>\n<\/blockquote>\n
                        \n
                        Riepilogo<\/h3>\n
                          \n
                        • Il firmware (BIOS o UEFI) inizializza l’hardware ed esegue il POST.<\/li>\n
                        • Il bootloader carica il kernel Linux e l’initramfs.<\/li>\n
                        • Il kernel inizializza il sistema e prepara l’ambiente di esecuzione.<\/li>\n
                        • L’initramfs permette di montare il filesystem root.<\/li>\n
                        • Il sistema di inizializzazione (systemd) avvia servizi, demoni e presenta la schermata di login.<\/li>\n<\/ul>\n
                          101.2.3 I sistemi di inizializzazione (Init Systems)<\/h2>\n
                          Una volta che il kernel Linux ha completato l’inizializzazione dell’hardware e montato il filesystem principale, il controllo del sistema viene affidato al sistema di inizializzazione<\/strong>, comunemente chiamato init system<\/strong>.<\/p>\n
                          L’init system \u00e8 il primo processo eseguito nello spazio utente e possiede sempre il Process ID (PID) 1<\/strong>. Il suo compito \u00e8 preparare il sistema all’utilizzo, avviando tutti i servizi e i processi necessari per il corretto funzionamento del sistema operativo.<\/p>\n
                          Tra le sue principali responsabilit\u00e0 troviamo:<\/p>\n
                            \n
                          • avviare i servizi di sistema (daemon);<\/li>\n
                          • montare i filesystem aggiuntivi;<\/li>\n
                          • configurare la rete;<\/li>\n
                          • gestire i processi di sistema;<\/li>\n
                          • presentare la schermata di login.<\/li>\n<\/ul>\n
                            \n
                            \ud83d\udca1 Exam Tip<\/strong> Il primo processo avviato dal kernel nello spazio utente ha sempre PID 1<\/strong>. Nei sistemi Linux moderni questo processo \u00e8 quasi sempre systemd<\/strong>.<\/p>\n<\/blockquote>\n
                            \n
                            SysVinit<\/h3>\n
                            SysVinit<\/strong> (System V Init) \u00e8 stato per molti anni il sistema di inizializzazione standard delle distribuzioni Linux.<\/p>\n
                            Si basa su una serie di script di shell che vengono eseguiti in un ordine prestabilito durante l’avvio e l’arresto del sistema.<\/p>\n
                            Le principali caratteristiche di SysVinit sono:<\/p>\n
                              \n
                            • configurazione basata su script;<\/li>\n
                            • esecuzione sequenziale dei servizi;<\/li>\n
                            • utilizzo dei runlevel per definire lo stato operativo del sistema.<\/li>\n<\/ul>\n
                              I file di configurazione principali sono:<\/p>\n
                                \n
                              • \/etc\/inittab<\/code> (nelle distribuzioni che lo utilizzano);<\/li>\n
                              • \/etc\/init.d\/<\/code>, contenente gli script di avvio dei servizi.<\/li>\n<\/ul>\n
                                Sebbene SysVinit sia stato quasi completamente sostituito, \u00e8 ancora importante conoscerne il funzionamento perch\u00e9 compare frequentemente nelle domande LPIC.<\/p>\n
                                \n
                                Upstart<\/h3>\n
                                Upstart<\/strong> \u00e8 un sistema di inizializzazione sviluppato da Canonical come evoluzione di SysVinit.<\/p>\n
                                A differenza di SysVinit, che avviava i servizi in una sequenza fissa, Upstart introduceva un modello event-driven<\/strong>, nel quale i servizi venivano avviati in risposta a specifici eventi del sistema.<\/p>\n
                                Questo approccio permetteva di:<\/p>\n
                                  \n
                                • ridurre i tempi di avvio;<\/li>\n
                                • gestire meglio i servizi dinamici;<\/li>\n
                                • reagire automaticamente ai cambiamenti dello stato del sistema.<\/li>\n<\/ul>\n
                                  Upstart \u00e8 stato utilizzato per alcuni anni, soprattutto nelle versioni meno recenti di Ubuntu, ma oggi \u00e8 stato quasi completamente sostituito da systemd<\/strong>.<\/p>\n
                                  \n
                                  \ud83d\udccc Da ricordare<\/strong> Upstart rappresenta una fase di transizione tra il tradizionale SysVinit e il moderno systemd.<\/p>\n<\/blockquote>\n
                                  \n
                                  systemd<\/h3>\n
                                  Oggi la quasi totalit\u00e0 delle distribuzioni Linux utilizza systemd<\/strong> come sistema di inizializzazione.<\/p>\n
                                  A differenza di SysVinit, systemd utilizza file di configurazione chiamati unit file<\/strong>, che descrivono servizi, dispositivi, punti di mount e molte altre risorse del sistema.<\/p>\n
                                  Tra i principali vantaggi di systemd troviamo:<\/p>\n
                                    \n
                                  • avvio parallelo dei servizi;<\/li>\n
                                  • gestione delle dipendenze tra servizi;<\/li>\n
                                  • maggiore velocit\u00e0 di boot;<\/li>\n
                                  • integrazione con il journal di sistema (journalctl<\/code>);<\/li>\n
                                  • gestione centralizzata dei servizi tramite il comando systemctl<\/code>.<\/li>\n<\/ul>\n
                                    I file di configurazione delle unit\u00e0 sono generalmente memorizzati nelle directory:<\/p>\n
                                    \/usr\/lib\/systemd\/system\/\r\n\/etc\/systemd\/system\/<\/code><\/pre>\n
                                    \n
                                    Gestione dei servizi con systemctl<\/h3>\n
                                    Il comando principale per amministrare systemd \u00e8 systemctl<\/strong>.<\/p>\n
                                    Alcuni dei comandi pi\u00f9 utilizzati sono:<\/p>\n\n\n\n\n\n\n\n\n\n\n
                                    Comando<\/th>\nDescrizione<\/th>\n<\/tr>\n<\/thead>\n
                                    systemctl start nome_servizio<\/code><\/td>\nAvvia un servizio.<\/td>\n<\/tr>\n
                                    systemctl stop nome_servizio<\/code><\/td>\nArresta un servizio.<\/td>\n<\/tr>\n
                                    systemctl restart nome_servizio<\/code><\/td>\nRiavvia un servizio.<\/td>\n<\/tr>\n
                                    systemctl status nome_servizio<\/code><\/td>\nVisualizza lo stato di un servizio.<\/td>\n<\/tr>\n
                                    systemctl enable nome_servizio<\/code><\/td>\nAbilita l’avvio automatico del servizio al boot.<\/td>\n<\/tr>\n
                                    systemctl disable nome_servizio<\/code><\/td>\nDisabilita l’avvio automatico del servizio.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                                    Ad esempio:<\/p>\n
                                    sudo systemctl start ssh\r\nsudo systemctl enable ssh<\/code><\/pre>\n
                                    Il primo comando avvia immediatamente il servizio SSH, mentre il secondo ne abilita l’avvio automatico ad ogni accensione del sistema.<\/p>\n
                                    \n
                                    \u26a0\ufe0f Errore comune<\/strong> Molti utenti confondono start<\/code> con enable<\/code>. start<\/strong> avvia il servizio solo nella sessione corrente, mentre enable<\/strong> lo configura affinch\u00e9 venga avviato automaticamente ai successivi riavvii.<\/p>\n<\/blockquote>\n
                                    \n
                                    Confronto tra i principali sistemi di inizializzazione<\/h3>\n\n\n\n\n\n\n\n
                                    Init System<\/th>\nCaratteristica principale<\/th>\nStato attuale<\/th>\n<\/tr>\n<\/thead>\n
                                    SysVinit<\/strong><\/td>\nScript e runlevel<\/td>\nStorico<\/td>\n<\/tr>\n
                                    Upstart<\/strong><\/td>\nAvvio basato su eventi<\/td>\nObsoleto<\/td>\n<\/tr>\n
                                    systemd<\/strong><\/td>\nUnit file e gestione centralizzata dei servizi<\/td>\nStandard attuale<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                                    \n
                                    \u2699\ufe0f Best Practice<\/strong> Anche se oggi quasi tutte le distribuzioni utilizzano systemd, un amministratore Linux dovrebbe conoscere anche SysVinit e Upstart, poich\u00e9 possono comparire nella documentazione tecnica, in sistemi legacy e nelle domande d’esame LPIC.<\/p>\n<\/blockquote>\n
                                    \n
                                    Riepilogo<\/h3>\n
                                      \n
                                    • L’init system \u00e8 il primo processo dello spazio utente e possiede sempre il PID 1.<\/li>\n
                                    • SysVinit utilizza script di shell e runlevel.<\/li>\n
                                    • Upstart \u00e8 stato un sistema di inizializzazione basato su eventi.<\/li>\n
                                    • Systemd \u00e8 il sistema di inizializzazione utilizzato dalla maggior parte delle distribuzioni Linux moderne.<\/li>\n
                                    • Il comando systemctl<\/code> permette di gestire servizi e unit\u00e0 di systemd.<\/li>\n<\/ul>\n
                                      101.2.4 Log di avvio e diagnostica<\/h2>\n
                                      Quando un sistema Linux non si avvia correttamente, la prima attivit\u00e0 dell’amministratore consiste nell’analizzare i messaggi generati durante il processo di boot.<\/p>\n
                                      Linux mette a disposizione diversi strumenti per consultare questi messaggi e individuare eventuali errori relativi al kernel, ai driver, ai filesystem o ai servizi di sistema.<\/p>\n
                                      Tra gli strumenti pi\u00f9 utilizzati troviamo dmesg<\/strong> e journalctl<\/strong>, entrambi fondamentali per la diagnostica del sistema.<\/p>\n
                                      \n
                                      \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 importante conoscere la differenza tra dmesg<\/code> e journalctl<\/code>. Il primo mostra i messaggi del kernel, mentre il secondo permette di consultare il journal di systemd.<\/p>\n<\/blockquote>\n
                                      \n
                                      Il comando dmesg<\/h3>\n
                                      Il comando dmesg<\/strong> visualizza il contenuto del kernel ring buffer<\/strong>, ovvero i messaggi generati dal kernel durante il processo di avvio e durante il funzionamento del sistema.<\/p>\n
                                      Questi messaggi riguardano principalmente:<\/p>\n
                                        \n
                                      • rilevamento dell’hardware;<\/li>\n
                                      • caricamento dei driver;<\/li>\n
                                      • inizializzazione dei dispositivi;<\/li>\n
                                      • errori del kernel;<\/li>\n
                                      • filesystem e periferiche.<\/li>\n<\/ul>\n
                                        Per visualizzare i messaggi del kernel:<\/p>\n
                                        dmesg<\/code><\/pre>\n
                                        Poich\u00e9 l’output pu\u00f2 essere molto esteso, \u00e8 comune utilizzare un pager:<\/p>\n
                                        dmesg | less<\/code><\/pre>\n
                                        Oppure filtrare eventuali errori:<\/p>\n
                                        dmesg | grep -i error<\/code><\/pre>\n
                                        \n
                                        Il comando journalctl<\/h3>\n
                                        Nei sistemi che utilizzano systemd<\/strong>, i messaggi di sistema vengono archiviati nel systemd journal<\/strong>.<\/p>\n
                                        Il comando journalctl<\/code> consente di consultare questi log applicando numerosi filtri.<\/p>\n
                                        Per visualizzare tutti i messaggi dell’avvio corrente:<\/p>\n
                                        journalctl -b<\/code><\/pre>\n
                                        Per consultare il boot precedente:<\/p>\n
                                        journalctl -b -1<\/code><\/pre>\n
                                        Per visualizzare solamente gli errori:<\/p>\n
                                        journalctl -p err -b<\/code><\/pre>\n
                                        Per consultare i log di un determinato servizio:<\/p>\n
                                        journalctl -u ssh.service<\/code><\/pre>\n
                                        \n
                                        \ud83d\udccc Da ricordare<\/strong> Il parametro -b<\/code> limita la visualizzazione ai messaggi relativi al processo di boot.<\/p>\n<\/blockquote>\n
                                        \n
                                        Scenario pratico: il sistema si blocca durante l’avvio<\/h3>\n
                                        Supponiamo che il sistema Linux si blocchi subito dopo il menu di GRUB e non completi l’avvio.<\/p>\n
                                        Le possibili cause possono essere diverse:<\/p>\n
                                          \n
                                        • problemi durante l’inizializzazione dell’hardware;<\/li>\n
                                        • driver del kernel non funzionanti;<\/li>\n
                                        • initramfs danneggiato;<\/li>\n
                                        • filesystem root corrotto;<\/li>\n
                                        • servizi essenziali che non riescono ad avviarsi.<\/li>\n<\/ul>\n
                                          In questi casi \u00e8 possibile:<\/p>\n
                                            \n
                                          1. avviare il sistema in modalit\u00e0 di ripristino (Recovery Mode);<\/li>\n
                                          2. consultare i messaggi del kernel con dmesg<\/code>;<\/li>\n
                                          3. analizzare i log del boot tramite journalctl -b<\/code>;<\/li>\n
                                          4. verificare eventuali servizi non avviati correttamente.<\/li>\n<\/ol>\n
                                            Ad esempio, il comando:<\/p>\n
                                            systemctl --failed<\/code><\/pre>\n
                                            mostra tutti i servizi che risultano in stato di errore.<\/p>\n
                                            \n
                                            Quando utilizzare questi strumenti<\/h3>\n\n\n\n\n\n\n\n\n\n
                                            Comando<\/th>\nUtilizzo principale<\/th>\n<\/tr>\n<\/thead>\n
                                            dmesg<\/code><\/td>\nVisualizza i messaggi del kernel.<\/td>\n<\/tr>\n
                                            journalctl -b<\/code><\/td>\nMostra i log dell’avvio corrente.<\/td>\n<\/tr>\n
                                            journalctl -b -1<\/code><\/td>\nVisualizza i log del boot precedente.<\/td>\n<\/tr>\n
                                            journalctl -u servizio<\/code><\/td>\nMostra i log di un servizio.<\/td>\n<\/tr>\n
                                            systemctl --failed<\/code><\/td>\nElenca i servizi che non sono stati avviati correttamente.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                                            \n
                                            \u26a0\ufe0f Errore comune<\/strong> Molti utenti utilizzano esclusivamente dmesg<\/code> per cercare un problema di avvio. Nei sistemi moderni, tuttavia, gran parte delle informazioni \u00e8 disponibile tramite journalctl<\/code>, che offre strumenti di ricerca e filtraggio molto pi\u00f9 avanzati.<\/p>\n<\/blockquote>\n
                                            \n
                                            \u2699\ufe0f Best Practice<\/strong> Quando un sistema presenta problemi durante il boot, \u00e8 consigliabile seguire questo ordine di verifica:<\/p>\n
                                              \n
                                            1. consultare dmesg<\/code> per individuare eventuali errori del kernel;<\/li>\n
                                            2. analizzare i log con journalctl -b<\/code>;<\/li>\n
                                            3. verificare i servizi non avviati tramite systemctl --failed<\/code>;<\/li>\n
                                            4. controllare lo stato dei singoli servizi con systemctl status nome_servizio<\/code>.<\/li>\n<\/ol>\n<\/blockquote>\n
                                              \n
                                              Riepilogo<\/h3>\n
                                                \n
                                              • dmesg<\/code> visualizza i messaggi del kernel.<\/li>\n
                                              • journalctl<\/code> permette di consultare il systemd journal.<\/li>\n
                                              • journalctl -b<\/code> mostra i log dell’avvio corrente.<\/li>\n
                                              • journalctl -b -1<\/code> permette di analizzare il boot precedente.<\/li>\n
                                              • La consultazione dei log rappresenta uno degli strumenti pi\u00f9 efficaci per diagnosticare problemi di avvio.<\/li>\n<\/ul>\n
                                                \ud83d\udcda Riepilogo della lezione<\/h2>\n
                                                In questa lezione hai approfondito il processo di avvio di un sistema Linux, analizzando tutte le fasi che portano dall’accensione del computer fino alla presentazione della schermata di login. Hai scoperto il ruolo del firmware BIOS\/UEFI, del bootloader, del kernel Linux, dell’initramfs e del sistema di inizializzazione, comprendendo come questi componenti collaborano per rendere il sistema operativo pienamente funzionante.<\/p>\n
                                                Hai inoltre imparato a utilizzare gli strumenti principali per analizzare il processo di boot e diagnosticare eventuali problemi di avvio attraverso i log del kernel e del systemd journal.<\/p>\n
                                                Concetti principali<\/h3>\n
                                                  \n
                                                • Hai compreso il ruolo del bootloader<\/strong> e dei parametri del kernel durante il processo di avvio.<\/li>\n
                                                • Hai analizzato la sequenza completa del boot, dall’accensione del computer fino alla schermata di login.<\/li>\n
                                                • Hai distinto il funzionamento di BIOS<\/strong> e UEFI<\/strong> e il loro ruolo nell’inizializzazione dell’hardware.<\/li>\n
                                                • Hai compreso le funzioni del kernel Linux<\/strong> e dell’initramfs<\/strong> durante il boot.<\/li>\n
                                                • Hai conosciuto i principali sistemi di inizializzazione: SysVinit<\/strong>, Upstart<\/strong> e systemd<\/strong>.<\/li>\n
                                                • Hai imparato a utilizzare dmesg<\/code> e journalctl<\/code> per analizzare i messaggi di avvio del sistema.<\/li>\n
                                                • Hai acquisito le basi per diagnosticare i pi\u00f9 comuni problemi che possono verificarsi durante il processo di boot.<\/li>\n<\/ul>\n
                                                  \n
                                                  \ud83c\udfaf Obiettivo raggiunto<\/strong> Al termine di questa lezione sei in grado di descrivere tutte le principali fasi del processo di avvio di Linux, comprendere il ruolo dei componenti coinvolti e utilizzare gli strumenti fondamentali per analizzare e diagnosticare eventuali problemi di boot.<\/p>\n<\/blockquote>\n
                                                  Comandi da ricordare<\/h3>\n\n\n\n\n\n\n\n\n\n\n\n\n\n
                                                  Comando<\/th>\nDescrizione<\/th>\n<\/tr>\n<\/thead>\n
                                                  dmesg<\/code><\/td>\nVisualizza i messaggi del kernel.<\/td>\n<\/tr>\n
                                                  dmesg | less<\/code><\/td>\nMostra i messaggi del kernel tramite un pager.<\/td>\n<\/tr>\n
                                                  journalctl -b<\/code><\/td>\nVisualizza i log dell’avvio corrente.<\/td>\n<\/tr>\n
                                                  journalctl -b -1<\/code><\/td>\nVisualizza i log dell’avvio precedente.<\/td>\n<\/tr>\n
                                                  journalctl -u nome_servizio<\/code><\/td>\nMostra i log di uno specifico servizio.<\/td>\n<\/tr>\n
                                                  systemctl start nome_servizio<\/code><\/td>\nAvvia un servizio.<\/td>\n<\/tr>\n
                                                  systemctl enable nome_servizio<\/code><\/td>\nAbilita l’avvio automatico di un servizio.<\/td>\n<\/tr>\n
                                                  systemctl status nome_servizio<\/code><\/td>\nVisualizza lo stato di un servizio.<\/td>\n<\/tr>\n
                                                  systemctl --failed<\/code><\/td>\nElenca i servizi che risultano in errore.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                                                  \n
                                                  \ud83d\udca1 Preparazione all’esame LPIC-1<\/strong> Prima di proseguire assicurati di conoscere l’ordine corretto delle fasi del boot, il ruolo di BIOS\/UEFI, GRUB, kernel, initramfs e systemd e di saper distinguere quando utilizzare dmesg<\/code> oppure journalctl<\/code>. Questi argomenti sono tra i pi\u00f9 richiesti nelle domande dell’esame LPIC-1 Exam 101.<\/p>\n<\/blockquote>\n
                                                  \n
                                                  \u27a1\ufe0f Prossima lezione<\/h2>\n
                                                  Nella prossima lezione (101.3 Cambiare i runlevel, target di avvio e spegnere o riavviare il sistema<\/strong>) approfondirai il funzionamento dei runlevel tradizionali e dei target di systemd<\/strong>, imparando a gestire correttamente l’avvio, l’arresto e il riavvio di un sistema Linux.<\/p>\n","protected":false},"comment_status":"open","ping_status":"closed","template":"","class_list":["post-3583","lesson","type-lesson","status-publish","has-post-thumbnail","hentry"],"uagb_featured_image_src":[],"uagb_author_info":{"display_name":"Rootmail Academy","author_link":"https:\/\/rootmail.it\/en\/author\/"},"uagb_comment_info":0,"uagb_excerpt":"101.2 Avviare il sistema L’avvio di un sistema Linux \u00e8 un processo composto da diverse fasi, durante le quali firmware, bootloader, kernel e sistema di inizializzazione collaborano per rendere il computer operativo. Comprendere il funzionamento del processo di boot \u00e8 una competenza fondamentale per qualsiasi amministratore di sistema. Molti problemi di avvio possono infatti essere…","_links":{"self":[{"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/lesson\/3583","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/lesson"}],"about":[{"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/types\/lesson"}],"replies":[{"embeddable":true,"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/comments?post=3583"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/media\/3665"}],"wp:attachment":[{"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/media?parent=3583"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}