{"id":3619,"date":"2026-07-13T18:02:43","date_gmt":"2026-07-13T16:02:43","guid":{"rendered":"https:\/\/rootmail.it\/courses\/lpic-1-exam-101-010-160-corso-completo-in-italiano\/lessons\/101-3-cambiare-i-runlevel-i-target-di-avvio-e-arrestare-o-riavviare-il-sistema\/"},"modified":"2026-07-20T21:55:14","modified_gmt":"2026-07-20T19:55:14","slug":"101-3-cambiare-i-runlevel-i-target-di-avvio-e-arrestare-o-riavviare-il-sistema","status":"publish","type":"lesson","link":"https:\/\/rootmail.it\/en\/courses\/lpic-1-exam-1-101-500-corso-completo-in-italiano\/lessons\/101-3-cambiare-i-runlevel-i-target-di-avvio-e-arrestare-o-riavviare-il-sistema\/","title":{"rendered":"101.3 Cambiare i runlevel, i target di avvio e arrestare o riavviare il sistema"},"content":{"rendered":"

101.3 Cambiare i runlevel, i target di avvio e arrestare o riavviare il sistema<\/h2>\n

Dopo aver compreso il processo di avvio di Linux, \u00e8 importante conoscere come il sistema gestisce i diversi stati operativi e come amministrare correttamente le operazioni di avvio, arresto e riavvio.<\/p>\n

Nelle distribuzioni Linux moderne il tradizionale concetto di runlevel<\/strong>, introdotto da SysVinit, \u00e8 stato sostituito dai target<\/strong> di systemd<\/strong>. Sebbene i target rappresentino oggi lo standard, i runlevel continuano a essere un argomento richiesto nell’esame LPIC-1 e sono ancora presenti nella documentazione di molti sistemi legacy.<\/p>\n

In questa lezione scoprirai come funzionano i runlevel e i target di systemd, come cambiare modalit\u00e0 di avvio del sistema e quali comandi utilizzare per arrestare, riavviare o spegnere Linux in modo sicuro.<\/p>\n

\n

\ud83d\udca1 Exam Tip<\/strong> L’esame LPIC-1 richiede di conoscere sia i runlevel di SysVinit sia i target di systemd, oltre ai principali comandi utilizzati per arrestare, riavviare e modificare lo stato operativo del sistema.<\/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 il significato dei runlevel tradizionali di SysVinit;<\/li>\n
  • riconoscere la corrispondenza tra runlevel e target di systemd;<\/li>\n
  • visualizzare e modificare il target di avvio predefinito;<\/li>\n
  • passare da un target all’altro utilizzando systemctl<\/code>;<\/li>\n
  • arrestare, riavviare e spegnere un sistema Linux in modo sicuro;<\/li>\n
  • comprendere il funzionamento delle modalit\u00e0 di emergenza e di ripristino.<\/li>\n<\/ul>\n
    \n

    Argomenti trattati<\/h2>\n
      \n
    • Runlevel di SysVinit.<\/li>\n
    • Target di systemd.<\/li>\n
    • Corrispondenza tra runlevel e target.<\/li>\n
    • Visualizzare e modificare il target predefinito.<\/li>\n
    • Modalit\u00e0 rescue ed emergency.<\/li>\n
    • Comandi per arrestare, spegnere e riavviare il sistema.<\/li>\n<\/ul>\n
      \n

      101.3.1 Comprendere i runlevel<\/h2>\n

      Nei sistemi Linux basati su SysVinit<\/strong>, un runlevel<\/strong> rappresenta lo stato operativo del sistema dopo il completamento del processo di avvio.<\/p>\n

      Ogni runlevel definisce quali servizi devono essere avviati o arrestati, permettendo al sistema di funzionare in modalit\u00e0 differenti a seconda delle esigenze dell’amministratore.<\/p>\n

      Ad esempio, un server di produzione viene normalmente avviato in modalit\u00e0 multiutente, mentre durante attivit\u00e0 di manutenzione pu\u00f2 essere utile avviare il sistema in modalit\u00e0 utente singolo.<\/p>\n

      \n

      \ud83d\udca1 Exam Tip<\/strong> I runlevel sono un concetto storico legato a SysVinit<\/strong>. Sebbene le distribuzioni moderne utilizzino systemd<\/strong>, l’LPIC-1 richiede ancora di conoscerne il significato e le principali caratteristiche.<\/p>\n<\/blockquote>\n

      \n

      I runlevel tradizionali<\/h3>\n

      La seguente tabella riassume i runlevel utilizzati nei sistemi SysVinit.<\/p>\n\n\n\n\n\n\n\n\n\n\n\n
      Runlevel<\/th>\nDescrizione<\/th>\n<\/tr>\n<\/thead>\n
      0<\/strong><\/td>\nArresto del sistema (Halt).<\/td>\n<\/tr>\n
      1<\/strong><\/td>\nModalit\u00e0 utente singolo (Single-user mode), utilizzata principalmente per manutenzione e ripristino.<\/td>\n<\/tr>\n
      2<\/strong><\/td>\nModalit\u00e0 multiutente. Il significato pu\u00f2 variare in base alla distribuzione.<\/td>\n<\/tr>\n
      3<\/strong><\/td>\nModalit\u00e0 multiutente con servizi di rete. Generalmente senza interfaccia grafica.<\/td>\n<\/tr>\n
      4<\/strong><\/td>\nRunlevel normalmente non utilizzato e disponibile per personalizzazioni.<\/td>\n<\/tr>\n
      5<\/strong><\/td>\nModalit\u00e0 multiutente con interfaccia grafica (GUI).<\/td>\n<\/tr>\n
      6<\/strong><\/td>\nRiavvio del sistema (Reboot).<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
      \n

      \ud83d\udccc Da ricordare<\/strong> I runlevel 0<\/strong> e 6<\/strong> sono destinati rispettivamente allo spegnimento<\/strong> e al riavvio<\/strong> del sistema. Non devono essere impostati come runlevel predefiniti.<\/p>\n<\/blockquote>\n

      \n

      Il file \/etc\/inittab<\/h3>\n

      Nei sistemi basati su SysVinit<\/strong>, il file:<\/p>\n

      \/etc\/inittab<\/code><\/pre>\n
      contiene la configurazione principale del sistema di inizializzazione.<\/p>\n
      Tra le varie impostazioni, definisce anche il runlevel predefinito<\/strong> con cui il sistema deve essere avviato.<\/p>\n
      Un esempio \u00e8 il seguente:<\/p>\n
      id:3:initdefault:<\/code><\/pre>\n
      In questo caso il sistema verr\u00e0 avviato automaticamente nel runlevel 3<\/strong>.<\/p>\n
      Oltre al runlevel predefinito, il file \/etc\/inittab<\/code> pu\u00f2 contenere istruzioni relative all’avvio di terminali virtuali, script di inizializzazione e altre configurazioni del sistema.<\/p>\n
      \n
      \u26a0\ufe0f Errore comune<\/strong> Molti amministratori cercano il file \/etc\/inittab<\/code> anche nelle distribuzioni moderne. Nei sistemi che utilizzano systemd<\/strong> questo file \u00e8 generalmente assente oppure ignorato, poich\u00e9 \u00e8 stato sostituito dal concetto di target<\/strong>.<\/p>\n<\/blockquote>\n
      \n
      Perch\u00e9 conoscere ancora i runlevel?<\/h3>\n
      Anche se oggi quasi tutte le distribuzioni Linux utilizzano systemd<\/strong>, la conoscenza dei runlevel rimane importante perch\u00e9:<\/p>\n
        \n
      • sono ancora presenti nella documentazione tecnica e nei sistemi legacy;<\/li>\n
      • molti script di amministrazione fanno ancora riferimento ai runlevel;<\/li>\n
      • compaiono frequentemente nelle domande della certificazione LPIC-1;<\/li>\n
      • costituiscono la base concettuale dei moderni target di systemd.<\/li>\n<\/ul>\n
        \n
        \u2699\ufe0f Best Practice<\/strong> Quando lavori su sistemi Linux moderni utilizza i target di systemd<\/strong>. Tuttavia, \u00e8 consigliabile conoscere anche i runlevel tradizionali per poter amministrare sistemi meno recenti e affrontare con sicurezza l’esame LPIC-1.<\/p>\n<\/blockquote>\n
        \n
        Riepilogo<\/h3>\n
          \n
        • Un runlevel rappresenta lo stato operativo di un sistema Linux basato su SysVinit.<\/li>\n
        • Ogni runlevel determina quali servizi devono essere avviati.<\/li>\n
        • Il file \/etc\/inittab<\/code> definiva il runlevel predefinito nei sistemi SysVinit.<\/li>\n
        • I runlevel sono stati sostituiti dai target di systemd, ma rimangono un argomento importante per la certificazione LPIC-1.<\/li>\n<\/ul>\n
          101.3.2 Impostare il runlevel o il target di avvio predefinito<\/h2>\n
          Dopo aver compreso il concetto di runlevel<\/strong>, \u00e8 importante sapere come configurare lo stato operativo con cui il sistema viene avviato automaticamente.<\/p>\n
          Nei sistemi Linux tradizionali basati su SysVinit<\/strong>, questa configurazione veniva effettuata modificando il file \/etc\/inittab<\/code>. Nelle distribuzioni moderne che utilizzano systemd<\/strong>, invece, il concetto di runlevel \u00e8 stato sostituito dai target<\/strong>, che offrono una gestione pi\u00f9 flessibile dell’avvio del sistema.<\/p>\n
          \n
          \ud83d\udca1 Exam Tip<\/strong> L’esame LPIC-1 pu\u00f2 presentare domande sia sui runlevel di SysVinit sia sui target di systemd. \u00c8 importante conoscere entrambi i metodi, anche se oggi quasi tutte le distribuzioni utilizzano systemd.<\/p>\n<\/blockquote>\n
          \n
          Impostare il runlevel predefinito con SysVinit<\/h3>\n
          Nei sistemi basati su SysVinit<\/strong>, il runlevel predefinito viene definito nel file:<\/p>\n
          \/etc\/inittab<\/code><\/pre>\n
          All’interno del file \u00e8 presente una riga simile alla seguente:<\/p>\n
          id:3:initdefault:<\/code><\/pre>\n
          Il numero centrale rappresenta il runlevel che verr\u00e0 utilizzato automaticamente all’avvio del sistema.<\/p>\n
          Ad esempio:<\/p>\n
            \n
          • 3<\/strong> \u2192 modalit\u00e0 multiutente senza interfaccia grafica;<\/li>\n
          • 5<\/strong> \u2192 modalit\u00e0 multiutente con interfaccia grafica.<\/li>\n<\/ul>\n
            Per modificare il runlevel predefinito \u00e8 sufficiente sostituire il valore numerico e salvare il file.<\/p>\n
            \n
            \ud83d\udccc Da ricordare<\/strong> Il file \/etc\/inittab<\/code> viene utilizzato esclusivamente dai sistemi basati su SysVinit<\/strong>. Nelle distribuzioni moderne che utilizzano systemd questo file \u00e8 generalmente assente.<\/p>\n<\/blockquote>\n
            \n
            I target di systemd<\/h3>\n
            Con l’introduzione di systemd<\/strong>, i runlevel sono stati sostituiti dai target<\/strong>.<\/p>\n
            Un target rappresenta uno stato operativo del sistema e definisce quali servizi devono essere avviati.<\/p>\n
            I target pi\u00f9 comuni sono:<\/p>\n\n\n\n\n\n\n\n\n
            Target<\/th>\nDescrizione<\/th>\n<\/tr>\n<\/thead>\n
            multi-user.target<\/code><\/td>\nModalit\u00e0 multiutente senza interfaccia grafica.<\/td>\n<\/tr>\n
            graphical.target<\/code><\/td>\nModalit\u00e0 multiutente con interfaccia grafica.<\/td>\n<\/tr>\n
            rescue.target<\/code><\/td>\nModalit\u00e0 di ripristino con servizi essenziali.<\/td>\n<\/tr>\n
            emergency.target<\/code><\/td>\nModalit\u00e0 di emergenza con il minimo indispensabile di servizi.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
            \n
            Visualizzare il target predefinito<\/h3>\n
            Per conoscere il target configurato come predefinito \u00e8 possibile utilizzare il comando:<\/p>\n
            systemctl get-default<\/code><\/pre>\n
            L’output sar\u00e0 simile al seguente:<\/p>\n
            graphical.target<\/code><\/pre>\n
            oppure:<\/p>\n
            multi-user.target<\/code><\/pre>\n
            \n
            Modificare il target predefinito<\/h3>\n
            Per cambiare il target utilizzato all’avvio del sistema si utilizza il comando:<\/p>\n
            sudo systemctl set-default multi-user.target<\/code><\/pre>\n
            In questo esempio il sistema verr\u00e0 avviato automaticamente in modalit\u00e0 multiutente senza interfaccia grafica.<\/p>\n
            Per ripristinare l’avvio grafico \u00e8 possibile eseguire:<\/p>\n
            sudo systemctl set-default graphical.target<\/code><\/pre>\n
            La modifica sar\u00e0 applicata al successivo riavvio del sistema.<\/p>\n
            \n
            \ud83d\udca1 Exam Tip<\/strong> Il comando systemctl set-default<\/code> modifica il target di avvio predefinito<\/strong>, ma non cambia immediatamente lo stato operativo del sistema.<\/p>\n<\/blockquote>\n
            \n
            Runlevel e target: corrispondenza<\/h3>\n
            Per facilitare la migrazione da SysVinit a systemd, i principali runlevel sono associati ai corrispondenti target.<\/p>\n\n\n\n\n\n\n\n\n\n
            Runlevel (SysVinit)<\/th>\nTarget (systemd)<\/th>\n<\/tr>\n<\/thead>\n
            0<\/td>\npoweroff.target<\/code><\/td>\n<\/tr>\n
            1<\/td>\nrescue.target<\/code><\/td>\n<\/tr>\n
            3<\/td>\nmulti-user.target<\/code><\/td>\n<\/tr>\n
            5<\/td>\ngraphical.target<\/code><\/td>\n<\/tr>\n
            6<\/td>\nreboot.target<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
            Questa corrispondenza consente agli amministratori di sistema di orientarsi facilmente tra il modello tradizionale basato sui runlevel e quello moderno introdotto da systemd.<\/p>\n
            \n
            \u26a0\ufe0f Errore comune<\/strong> Il comando systemctl set-default<\/code> modifica solamente il target utilizzato al prossimo avvio. Per cambiare immediatamente il target corrente \u00e8 necessario utilizzare systemctl isolate<\/code>, che verr\u00e0 approfondito nella prossima sezione.<\/p>\n<\/blockquote>\n
            \n
            Best Practice<\/h3>\n
            Quando amministri sistemi Linux moderni utilizza sempre i target di systemd<\/strong>. Tuttavia, \u00e8 consigliabile conoscere anche il funzionamento dei runlevel e del file \/etc\/inittab<\/code>, poich\u00e9 possono essere ancora presenti in sistemi legacy e sono argomenti frequentemente richiesti nell’esame LPIC-1.<\/p>\n
            \n
            Riepilogo<\/h3>\n
              \n
            • Nei sistemi SysVinit il runlevel predefinito veniva definito nel file \/etc\/inittab<\/code>.<\/li>\n
            • Systemd sostituisce i runlevel con i target.<\/li>\n
            • Il comando systemctl get-default<\/code> visualizza il target predefinito.<\/li>\n
            • Il comando systemctl set-default<\/code> imposta il target utilizzato ai successivi avvii del sistema.<\/li>\n
            • I target multi-user.target<\/code> e graphical.target<\/code> sono i pi\u00f9 utilizzati nelle distribuzioni Linux moderne.<\/li>\n<\/ul>\n
              101.3.3 Cambiare runlevel e target di avvio<\/h2>\n
              In alcune situazioni un amministratore di sistema pu\u00f2 avere la necessit\u00e0 di modificare lo stato operativo del sistema senza riavviare il computer<\/strong>. Ad esempio, pu\u00f2 essere necessario passare dalla modalit\u00e0 grafica a quella testuale per eseguire attivit\u00e0 di manutenzione oppure avviare temporaneamente una modalit\u00e0 di ripristino.<\/p>\n
              Le modalit\u00e0 di cambio dipendono dal sistema di inizializzazione utilizzato:<\/p>\n
                \n
              • SysVinit<\/strong> utilizza il comando telinit<\/code> per cambiare runlevel.<\/li>\n
              • systemd<\/strong> utilizza il comando systemctl isolate<\/code> per attivare un diverso target.<\/li>\n<\/ul>\n
                \n
                \ud83d\udca1 Exam Tip<\/strong> Non confondere systemctl isolate<\/code> con systemctl set-default<\/code>. Il primo modifica il target corrente<\/strong>, mentre il secondo modifica il target utilizzato al prossimo avvio<\/strong>.<\/p>\n<\/blockquote>\n
                \n
                Cambiare runlevel con SysVinit<\/h3>\n
                Nei sistemi basati su SysVinit<\/strong>, il comando utilizzato per cambiare runlevel \u00e8:<\/p>\n
                telinit<\/code><\/pre>\n
                Ad esempio, per passare al runlevel 3:<\/p>\n
                sudo telinit 3<\/code><\/pre>\n
                Il sistema terminer\u00e0 i servizi non necessari per il nuovo runlevel e avvier\u00e0 quelli richiesti.<\/p>\n
                \u00c8 possibile utilizzare anche altri runlevel:<\/p>\n\n\n\n\n\n\n\n\n\n
                Comando<\/th>\nDescrizione<\/th>\n<\/tr>\n<\/thead>\n
                telinit 1<\/code><\/td>\nPassa alla modalit\u00e0 utente singolo.<\/td>\n<\/tr>\n
                telinit 3<\/code><\/td>\nPassa alla modalit\u00e0 multiutente testuale.<\/td>\n<\/tr>\n
                telinit 5<\/code><\/td>\nPassa alla modalit\u00e0 grafica (nelle distribuzioni che la utilizzano).<\/td>\n<\/tr>\n
                telinit 6<\/code><\/td>\nRiavvia il sistema.<\/td>\n<\/tr>\n
                telinit 0<\/code><\/td>\nArresta il sistema.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                \n
                Cambiare target con systemd<\/h3>\n
                Nei sistemi Linux moderni, il cambio dello stato operativo avviene tramite il comando:<\/p>\n
                systemctl isolate<\/code><\/pre>\n
                Questo comando arresta i servizi non appartenenti al nuovo target e avvia quelli necessari.<\/p>\n
                Ad esempio, per passare alla modalit\u00e0 grafica:<\/p>\n
                sudo systemctl isolate graphical.target<\/code><\/pre>\n
                Per passare invece alla modalit\u00e0 multiutente senza interfaccia grafica:<\/p>\n
                sudo systemctl isolate multi-user.target<\/code><\/pre>\n
                Il cambio di target avviene immediatamente e non richiede il riavvio del sistema.<\/p>\n
                \n
                I target pi\u00f9 utilizzati<\/h3>\n\n\n\n\n\n\n\n\n
                Target<\/th>\nDescrizione<\/th>\n<\/tr>\n<\/thead>\n
                multi-user.target<\/code><\/td>\nModalit\u00e0 multiutente senza interfaccia grafica.<\/td>\n<\/tr>\n
                graphical.target<\/code><\/td>\nModalit\u00e0 multiutente con interfaccia grafica.<\/td>\n<\/tr>\n
                rescue.target<\/code><\/td>\nModalit\u00e0 di ripristino con servizi essenziali.<\/td>\n<\/tr>\n
                emergency.target<\/code><\/td>\nModalit\u00e0 di emergenza con il minimo indispensabile di servizi.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                \n
                Quando utilizzare isolate<\/code>?<\/h3>\n
                Il comando systemctl isolate<\/code> \u00e8 particolarmente utile quando \u00e8 necessario modificare temporaneamente lo stato operativo del sistema senza riavviarlo.<\/p>\n
                Ad esempio pu\u00f2 essere utilizzato per:<\/p>\n
                  \n
                • passare dalla modalit\u00e0 grafica a quella testuale;<\/li>\n
                • eseguire operazioni di manutenzione;<\/li>\n
                • risolvere problemi relativi all’ambiente grafico;<\/li>\n
                • accedere rapidamente alla modalit\u00e0 di ripristino.<\/li>\n<\/ul>\n
                  Una volta completate le operazioni, \u00e8 possibile ritornare al target grafico eseguendo nuovamente il comando appropriato.<\/p>\n
                  \n
                  \ud83d\udccc Da ricordare<\/strong> systemctl isolate<\/code> modifica esclusivamente il target attivo nella sessione corrente. Al successivo riavvio il sistema utilizzer\u00e0 il target predefinito configurato con systemctl set-default<\/code>.<\/p>\n<\/blockquote>\n
                  \n
                  Confronto tra i principali comandi<\/h3>\n\n\n\n\n\n\n\n\n
                  Comando<\/th>\nEffetto<\/th>\n<\/tr>\n<\/thead>\n
                  telinit 3<\/code><\/td>\nCambia immediatamente il runlevel (SysVinit).<\/td>\n<\/tr>\n
                  systemctl isolate multi-user.target<\/code><\/td>\nCambia immediatamente il target corrente (systemd).<\/td>\n<\/tr>\n
                  systemctl set-default multi-user.target<\/code><\/td>\nImposta il target utilizzato ai successivi avvii del sistema.<\/td>\n<\/tr>\n
                  systemctl get-default<\/code><\/td>\nVisualizza il target di avvio predefinito.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                  \n
                  \u26a0\ufe0f Errore comune<\/strong> Molti utenti pensano che systemctl isolate<\/code> renda permanente la modifica del target. In realt\u00e0 il comando ha effetto solo sulla sessione corrente. Per modificare il target utilizzato ai successivi riavvii \u00e8 necessario utilizzare systemctl set-default<\/code>.<\/p>\n<\/blockquote>\n
                  \n
                  Best Practice<\/h3>\n
                  Quando amministri un sistema Linux moderno, utilizza systemctl isolate<\/code> solo se necessario e assicurati di comprendere quali servizi verranno arrestati o avviati. Prima di modificare il target predefinito verifica sempre quello attualmente configurato mediante systemctl get-default<\/code>.<\/p>\n
                  \n
                  Riepilogo<\/h3>\n
                    \n
                  • Nei sistemi SysVinit il comando telinit<\/code> permette di cambiare runlevel.<\/li>\n
                  • Nei sistemi moderni systemctl isolate<\/code> cambia immediatamente il target corrente.<\/li>\n
                  • systemctl isolate<\/code> non modifica il target di avvio predefinito.<\/li>\n
                  • systemctl set-default<\/code> imposta il target utilizzato ai successivi riavvii del sistema.<\/li>\n
                  • I target multi-user.target<\/code> e graphical.target<\/code> sono quelli utilizzati pi\u00f9 frequentemente.<\/li>\n<\/ul>\n
                    101.3.4 Arrestare, riavviare e gestire il sistema dalla riga di comando<\/h2>\n
                    Un amministratore Linux deve essere in grado di arrestare, riavviare o modificare lo stato operativo del sistema in modo sicuro. Queste operazioni possono essere eseguite direttamente dalla riga di comando utilizzando strumenti differenti a seconda del sistema di inizializzazione impiegato.<\/p>\n
                    Nei sistemi basati su SysVinit<\/strong> vengono utilizzati principalmente i comandi shutdown<\/code> e telinit<\/code>, mentre nelle distribuzioni moderne che adottano systemd<\/strong> si utilizzano i comandi systemctl<\/code>.<\/p>\n
                    \n
                    \ud83d\udca1 Exam Tip<\/strong> Per l’esame LPIC-1 \u00e8 importante conoscere sia i comandi tradizionali (shutdown<\/code>, halt<\/code>, reboot<\/code>) sia i corrispondenti comandi di systemd<\/strong>.<\/p>\n<\/blockquote>\n
                    \n
                    Arrestare il sistema (Shutdown)<\/h3>\n
                    L’arresto del sistema consente di chiudere ordinatamente tutti i processi, smontare i filesystem e spegnere il computer in sicurezza.<\/p>\n
                    Nei sistemi SysVinit si utilizza generalmente:<\/p>\n
                    sudo shutdown -h now<\/code><\/pre>\n
                    dove:<\/p>\n
                      \n
                    • -h<\/code> indica di arrestare il sistema (halt<\/em>);<\/li>\n
                    • now<\/code> indica che l’operazione deve essere eseguita immediatamente.<\/li>\n<\/ul>\n
                      Con systemd il comando equivalente \u00e8:<\/p>\n
                      sudo systemctl poweroff<\/code><\/pre>\n
                      Entrambi i comandi terminano i servizi in esecuzione e spengono il sistema in modo controllato.<\/p>\n
                      \n
                      Riavviare il sistema (Reboot)<\/h3>\n
                      Per riavviare il computer \u00e8 possibile utilizzare:<\/p>\n
                      sudo shutdown -r now<\/code><\/pre>\n
                      L’opzione -r<\/code> indica che, dopo l’arresto dei servizi, il sistema dovr\u00e0 essere riavviato.<\/p>\n
                      Nei sistemi moderni con systemd il comando equivalente \u00e8:<\/p>\n
                      sudo systemctl reboot<\/code><\/pre>\n
                      \n
                      Modalit\u00e0 utente singolo (Single-user mode)<\/h3>\n
                      La modalit\u00e0 utente singolo<\/strong> \u00e8 una modalit\u00e0 speciale utilizzata principalmente per:<\/p>\n
                        \n
                      • attivit\u00e0 di manutenzione;<\/li>\n
                      • ripristino del sistema;<\/li>\n
                      • correzione di errori nei filesystem;<\/li>\n
                      • modifica di configurazioni critiche.<\/li>\n<\/ul>\n
                        In questa modalit\u00e0 vengono avviati solamente i servizi essenziali e normalmente \u00e8 disponibile un unico utente con privilegi amministrativi.<\/p>\n
                        Nei sistemi SysVinit \u00e8 possibile accedervi con:<\/p>\n
                        sudo telinit 1<\/code><\/pre>\n
                        Con systemd il comando equivalente \u00e8:<\/p>\n
                        sudo systemctl isolate rescue.target<\/code><\/pre>\n
                        \n
                        \ud83d\udccc Da ricordare<\/strong> La modalit\u00e0 rescue.target<\/strong> rappresenta l’equivalente moderno del tradizionale runlevel 1<\/strong>.<\/p>\n<\/blockquote>\n
                        \n
                        Confronto dei principali comandi<\/h3>\n\n\n\n\n\n\n\n
                        Operazione<\/th>\nSysVinit<\/th>\nsystemd<\/th>\n<\/tr>\n<\/thead>\n
                        Spegnere il sistema<\/td>\nshutdown -h now<\/code><\/td>\nsystemctl poweroff<\/code><\/td>\n<\/tr>\n
                        Riavviare il sistema<\/td>\nshutdown -r now<\/code><\/td>\nsystemctl reboot<\/code><\/td>\n<\/tr>\n
                        Modalit\u00e0 utente singolo<\/td>\ntelinit 1<\/code><\/td>\nsystemctl isolate rescue.target<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                        \n
                        Altri comandi utili<\/h3>\n
                        Linux mette a disposizione anche altri comandi per la gestione dello stato del sistema:<\/p>\n\n\n\n\n\n\n\n\n\n
                        Comando<\/th>\nDescrizione<\/th>\n<\/tr>\n<\/thead>\n
                        poweroff<\/code><\/td>\nArresta e spegne il sistema.<\/td>\n<\/tr>\n
                        halt<\/code><\/td>\nFerma il sistema. Nei sistemi moderni equivale generalmente a poweroff<\/code>.<\/td>\n<\/tr>\n
                        reboot<\/code><\/td>\nRiavvia il sistema.<\/td>\n<\/tr>\n
                        shutdown +10<\/code><\/td>\nPianifica lo spegnimento tra 10 minuti.<\/td>\n<\/tr>\n
                        shutdown -c<\/code><\/td>\nAnnulla uno spegnimento pianificato.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                        \n
                        \u26a0\ufe0f Errore comune<\/strong> Evita di spegnere il computer interrompendo direttamente l’alimentazione. Utilizza sempre i comandi di arresto del sistema, che consentono di terminare correttamente i processi e smontare i filesystem, riducendo il rischio di perdita o corruzione dei dati.<\/p>\n<\/blockquote>\n
                        \n
                        Best Practice<\/h3>\n
                        Prima di arrestare o riavviare un server di produzione verifica sempre che non siano presenti utenti connessi o processi critici in esecuzione. Quando possibile, utilizza il comando shutdown<\/code> per pianificare lo spegnimento e avvisare gli utenti connessi.<\/p>\n
                        \n
                        Riepilogo<\/h3>\n
                          \n
                        • shutdown -h now<\/code> e systemctl poweroff<\/code> arrestano il sistema.<\/li>\n
                        • shutdown -r now<\/code> e systemctl reboot<\/code> riavviano il sistema.<\/li>\n
                        • telinit 1<\/code> e systemctl isolate rescue.target<\/code> consentono di accedere alla modalit\u00e0 di manutenzione.<\/li>\n
                        • I comandi di arresto terminano i servizi e smontano correttamente i filesystem prima dello spegnimento.<\/li>\n<\/ul>\n
                          101.3.5 Avvisare gli utenti connessi<\/h2>\n
                          In un ambiente multiutente \u00e8 buona norma informare gli utenti prima di eseguire operazioni che potrebbero interrompere il loro lavoro, come un riavvio del sistema, uno spegnimento o un intervento di manutenzione.<\/p>\n
                          Linux mette a disposizione il comando wall<\/code> (write all<\/strong>), che consente di inviare un messaggio contemporaneamente a tutti gli utenti attualmente connessi tramite terminale.<\/p>\n
                          Questo comando \u00e8 particolarmente utile negli ambienti server, dove pi\u00f9 utenti possono essere collegati contemporaneamente tramite console locale o connessioni SSH.<\/p>\n
                          \n
                          \ud83d\udca1 Exam Tip<\/strong> Il comando wall<\/code> invia un messaggio a tutti gli utenti connessi<\/strong>. Non deve essere confuso con write<\/code>, che invia un messaggio a un singolo utente.<\/p>\n<\/blockquote>\n
                          \n
                          Utilizzare il comando wall<\/h3>\n
                          La sintassi del comando \u00e8 molto semplice:<\/p>\n
                          wall \"messaggio\"<\/code><\/pre>\n
                          Ad esempio:<\/p>\n
                          wall \"Il sistema verr\u00e0 riavviato tra 10 minuti per manutenzione. Salvare il proprio lavoro.\"<\/code><\/pre>\n
                          Tutti gli utenti collegati riceveranno immediatamente il messaggio sul proprio terminale.<\/p>\n
                          \n
                          Quando utilizzare wall<\/h3>\n
                          Il comando wall<\/code> viene comunemente utilizzato prima di:<\/p>\n
                            \n
                          • uno spegnimento programmato del sistema;<\/li>\n
                          • un riavvio per installare aggiornamenti;<\/li>\n
                          • interventi di manutenzione;<\/li>\n
                          • operazioni amministrative che potrebbero interrompere le sessioni degli utenti.<\/li>\n<\/ul>\n
                            Un amministratore potrebbe, ad esempio, avvisare gli utenti alcuni minuti prima di riavviare un server:<\/p>\n
                            wall \"Attenzione: il server sar\u00e0 riavviato tra 10 minuti per manutenzione programmata.\"<\/code><\/pre>\n
                            \n
                            wall e shutdown<\/h3>\n
                            Quando si utilizza il comando shutdown<\/code> per pianificare uno spegnimento o un riavvio, Linux invia automaticamente un messaggio di avviso agli utenti connessi.<\/p>\n
                            Ad esempio:<\/p>\n
                            shutdown -r +10<\/code><\/pre>\n
                            programma il riavvio del sistema tra dieci minuti e notifica automaticamente gli utenti collegati.<\/p>\n
                            Il comando wall<\/code> rimane comunque utile quando si desidera inviare comunicazioni personalizzate oppure informare gli utenti senza pianificare uno spegnimento.<\/p>\n
                            \n
                            \ud83d\udccc Da ricordare<\/strong> shutdown<\/code> pu\u00f2 inviare automaticamente notifiche agli utenti, mentre wall<\/code> permette di inviare qualsiasi messaggio in qualunque momento.<\/p>\n<\/blockquote>\n
                            \n
                            Confronto tra wall e write<\/h3>\n\n\n\n\n\n\n
                            Comando<\/th>\nDescrizione<\/th>\n<\/tr>\n<\/thead>\n
                            wall<\/code><\/td>\nInvia un messaggio a tutti gli utenti connessi.<\/td>\n<\/tr>\n
                            write<\/code><\/td>\nInvia un messaggio a un singolo utente.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                            \n
                            \u26a0\ufe0f Errore comune<\/strong> Molti utenti credono che wall<\/code> invii messaggi tramite email. In realt\u00e0 il comando scrive direttamente sui terminali degli utenti attualmente connessi al sistema.<\/p>\n<\/blockquote>\n
                            \n
                            Best Practice<\/h3>\n
                            Prima di arrestare o riavviare un server condiviso, informa sempre gli utenti con un messaggio chiaro utilizzando wall<\/code> oppure pianificando lo spegnimento con shutdown<\/code>. Questo riduce il rischio di perdita di dati e permette agli utenti di salvare il proprio lavoro.<\/p>\n
                            \n
                            Riepilogo<\/h3>\n
                              \n
                            • Il comando wall<\/code> invia un messaggio a tutti gli utenti connessi.<\/li>\n
                            • \u00c8 particolarmente utile prima di operazioni di manutenzione, spegnimento o riavvio del sistema.<\/li>\n
                            • shutdown<\/code> pu\u00f2 notificare automaticamente gli utenti durante uno spegnimento pianificato.<\/li>\n
                            • Il comando write<\/code>, invece, permette di inviare un messaggio a un solo utente.<\/li>\n<\/ul>\n
                              101.3.6 Terminare correttamente i processi<\/h2>\n
                              Durante l’amministrazione di un sistema Linux pu\u00f2 essere necessario interrompere un processo che non risponde oppure arrestare un’applicazione prima di eseguire operazioni di manutenzione.<\/p>\n
                              Linux mette a disposizione diversi segnali per terminare un processo. Tuttavia, non tutti i segnali hanno lo stesso comportamento ed \u00e8 importante utilizzare quello pi\u00f9 appropriato per evitare la perdita di dati o la corruzione di file.<\/p>\n
                              \n
                              \ud83d\udca1 Exam Tip<\/strong> Quando possibile utilizza sempre il segnale TERM (15)<\/strong>, che consente al processo di terminare in modo ordinato. Il segnale KILL (9)<\/strong> dovrebbe essere utilizzato solo come ultima risorsa.<\/p>\n<\/blockquote>\n
                              \n
                              Terminazione “graceful” di un processo<\/h3>\n
                              Il comando pi\u00f9 comune per terminare un processo \u00e8:<\/p>\n
                              kill PID<\/code><\/pre>\n
                              oppure:<\/p>\n
                              kill -15 PID<\/code><\/pre>\n
                              Se non viene specificato alcun segnale, kill<\/code> invia automaticamente il segnale SIGTERM (15)<\/strong>.<\/p>\n
                              Questo segnale non forza l’interruzione immediata del processo, ma gli richiede di terminare correttamente.<\/p>\n
                              Il programma pu\u00f2 quindi:<\/p>\n
                                \n
                              • salvare eventuali dati ancora in memoria;<\/li>\n
                              • chiudere i file aperti;<\/li>\n
                              • rilasciare le risorse utilizzate;<\/li>\n
                              • terminare in modo ordinato.<\/li>\n<\/ul>\n
                                Per questo motivo SIGTERM<\/strong> rappresenta sempre la scelta consigliata.<\/p>\n
                                \n
                                Forzare la terminazione di un processo<\/h3>\n
                                Se un processo non risponde al segnale TERM, \u00e8 possibile utilizzare:<\/p>\n
                                kill -9 PID<\/code><\/pre>\n
                                Il parametro -9<\/code> invia il segnale SIGKILL<\/strong>, che interrompe immediatamente il processo.<\/p>\n
                                A differenza di SIGTERM, il processo:<\/p>\n
                                  \n
                                • non pu\u00f2 intercettare il segnale;<\/li>\n
                                • non pu\u00f2 eseguire operazioni di pulizia;<\/li>\n
                                • viene terminato immediatamente dal kernel.<\/li>\n<\/ul>\n
                                  Questo pu\u00f2 comportare la perdita di dati non ancora salvati o lasciare file temporanei e risorse non rilasciate.<\/p>\n
                                  \n
                                  \u26a0\ufe0f Errore comune<\/strong> Molti amministratori utilizzano immediatamente kill -9<\/code>. In realt\u00e0 \u00e8 buona pratica tentare prima una terminazione ordinata con kill<\/code> (SIGTERM) e ricorrere a SIGKILL<\/code> solo se il processo continua a non rispondere.<\/p>\n<\/blockquote>\n
                                  \n
                                  I principali segnali<\/h3>\n\n\n\n\n\n\n\n
                                  Segnale<\/th>\nNumero<\/th>\nDescrizione<\/th>\n<\/tr>\n<\/thead>\n
                                  SIGTERM<\/strong><\/td>\n15<\/td>\nRichiede al processo di terminare in modo ordinato.<\/td>\n<\/tr>\n
                                  SIGKILL<\/strong><\/td>\n9<\/td>\nForza la terminazione immediata del processo.<\/td>\n<\/tr>\n
                                  SIGHUP<\/strong><\/td>\n1<\/td>\nComunemente utilizzato per richiedere il ricaricamento della configurazione di un servizio.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                                  \n
                                  \ud83d\udccc Da ricordare<\/strong> Il comando kill<\/code> non “uccide” necessariamente un processo. Invia semplicemente un segnale<\/strong>; sar\u00e0 il processo stesso (quando possibile) a decidere come gestirlo.<\/p>\n<\/blockquote>\n
                                  \n
                                  Esempio pratico<\/h3>\n
                                  Supponiamo che un processo con PID 3245<\/code> non risponda.<\/p>\n
                                  Per tentare una chiusura ordinata:<\/p>\n
                                  kill 3245<\/code><\/pre>\n
                                  Se il processo continua a rimanere attivo, come ultima soluzione:<\/p>\n
                                  kill -9 3245<\/code><\/pre>\n
                                  \n
                                  Best Practice<\/h3>\n
                                  Quando \u00e8 necessario interrompere un processo, segui questo ordine:<\/p>\n
                                    \n
                                  1. identifica il PID del processo;<\/li>\n
                                  2. invia il segnale SIGTERM<\/strong> utilizzando kill PID<\/code>;<\/li>\n
                                  3. attendi alcuni secondi verificando se il processo termina;<\/li>\n
                                  4. solo se il processo continua a non rispondere utilizza kill -9 PID<\/code>.<\/li>\n<\/ol>\n
                                    \n
                                    Riepilogo<\/h3>\n
                                      \n
                                    • kill PID<\/code> invia il segnale SIGTERM (15)<\/strong>.<\/li>\n
                                    • SIGTERM permette al processo di terminare correttamente.<\/li>\n
                                    • kill -9 PID<\/code> invia SIGKILL (9)<\/strong>, che forza la terminazione immediata.<\/li>\n
                                    • SIGKILL dovrebbe essere utilizzato solo come ultima risorsa.<\/li>\n
                                    • Il comando kill<\/code> invia segnali ai processi e non li termina necessariamente in modo diretto.<\/li>\n<\/ul>\n
                                      101.3.7 Il demone acpid<\/h2>\n
                                      Nei sistemi Linux, molti eventi hardware legati alla gestione dell’alimentazione vengono gestiti dal demone acpid<\/strong> (Advanced Configuration and Power Interface daemon<\/strong>).<\/p>\n
                                      Il suo compito \u00e8 ascoltare gli eventi generati dall’interfaccia ACPI (Advanced Configuration and Power Interface)<\/strong> e avviare automaticamente le azioni configurate dall’amministratore di sistema.<\/p>\n
                                      Tra gli eventi pi\u00f9 comuni gestiti da acpid<\/strong> troviamo:<\/p>\n
                                        \n
                                      • pressione del pulsante di accensione;<\/li>\n
                                      • pressione del pulsante di sospensione;<\/li>\n
                                      • chiusura del coperchio di un computer portatile;<\/li>\n
                                      • collegamento o scollegamento dell’alimentatore;<\/li>\n
                                      • eventi relativi alla gestione energetica del sistema.<\/li>\n<\/ul>\n
                                        \n
                                        \ud83d\udca1 Exam Tip<\/strong> acpid<\/strong> \u00e8 un demone che intercetta gli eventi ACPI e avvia automaticamente le azioni associate. Non gestisce direttamente l’alimentazione del sistema, ma reagisce agli eventi hardware notificati dal kernel.<\/p>\n<\/blockquote>\n
                                        \n
                                        Come funziona acpid<\/h3>\n
                                        Quando si verifica un evento ACPI, il kernel Linux lo segnala al demone acpid<\/strong>.<\/p>\n
                                        Quest’ultimo consulta i file di configurazione e gli script associati all’evento per determinare quale operazione eseguire.<\/p>\n
                                        Ad esempio, alla chiusura del coperchio di un notebook pu\u00f2 essere configurato per:<\/p>\n
                                          \n
                                        • sospendere il sistema;<\/li>\n
                                        • ibernare il computer;<\/li>\n
                                        • spegnere lo schermo;<\/li>\n
                                        • non eseguire alcuna operazione.<\/li>\n<\/ul>\n
                                          Il comportamento dipende dalla configurazione del sistema e dalla distribuzione Linux utilizzata.<\/p>\n
                                          \n
                                          Configurazione<\/h3>\n
                                          Nei sistemi che utilizzano acpid<\/strong>, i file di configurazione sono generalmente presenti nella directory:<\/p>\n
                                          \/etc\/acpi\/<\/code><\/pre>\n
                                          Gli script contenuti in questa directory definiscono le azioni da eseguire quando viene rilevato uno specifico evento ACPI.<\/p>\n
                                          Nelle distribuzioni Linux moderne, alcune funzionalit\u00e0 tradizionalmente gestite da acpid<\/strong> possono essere integrate direttamente in systemd-logind<\/strong> o nell’ambiente desktop, riducendo la necessit\u00e0 di utilizzare il demone dedicato.<\/p>\n
                                          \n
                                          \ud83d\udccc Da ricordare<\/strong> Anche se molti sistemi moderni utilizzano systemd-logind<\/strong> per la gestione degli eventi ACPI, acpid<\/strong> continua a essere presente in numerose distribuzioni e rappresenta un argomento richiesto dall’esame LPIC-1.<\/p>\n<\/blockquote>\n
                                          \n
                                          Esempi di eventi gestiti<\/h3>\n\n\n\n\n\n\n\n\n
                                          Evento<\/th>\nAzione tipica<\/th>\n<\/tr>\n<\/thead>\n
                                          Pressione del pulsante di accensione<\/td>\nAvvio della procedura di spegnimento.<\/td>\n<\/tr>\n
                                          Chiusura del coperchio del notebook<\/td>\nSospensione o ibernazione del sistema.<\/td>\n<\/tr>\n
                                          Pressione del pulsante Sleep<\/td>\nSospensione del computer.<\/td>\n<\/tr>\n
                                          Collegamento dell’alimentatore<\/td>\nNotifica o modifica del profilo energetico.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                                          \n
                                          \u26a0\ufe0f Errore comune<\/strong> Molti utenti credono che acpid<\/strong> gestisca direttamente lo spegnimento del sistema. In realt\u00e0 il demone si limita a intercettare gli eventi ACPI ed eseguire gli script configurati.<\/p>\n<\/blockquote>\n
                                          \n
                                          Best Practice<\/h3>\n
                                          Quando amministri server Linux, verifica quali eventi ACPI sono realmente necessari. Nei server rack, ad esempio, la gestione della chiusura del coperchio non ha alcun significato, mentre pu\u00f2 essere utile controllare il comportamento del pulsante di accensione per evitare spegnimenti accidentali.<\/p>\n
                                          \n
                                          Riepilogo<\/h3>\n
                                            \n
                                          • acpid<\/strong> \u00e8 il demone che gestisce gli eventi ACPI.<\/li>\n
                                          • Intercetta eventi hardware come la pressione del pulsante di accensione o la chiusura del coperchio di un notebook.<\/li>\n
                                          • Esegue automaticamente gli script associati agli eventi rilevati.<\/li>\n
                                          • Nei sistemi moderni alcune funzionalit\u00e0 possono essere gestite direttamente da systemd-logind<\/strong>.<\/li>\n<\/ul>\n
                                            \ud83d\udcda Riepilogo della lezione<\/h2>\n
                                            In questa lezione hai approfondito il funzionamento dei diversi stati operativi di un sistema Linux, comprendendo il ruolo dei runlevel tradizionali e dei moderni target di systemd. Hai imparato a configurare il target di avvio predefinito, a modificare lo stato operativo del sistema senza riavviarlo e a utilizzare i principali comandi per arrestare, riavviare e amministrare il sistema in sicurezza.<\/p>\n
                                            Hai inoltre scoperto come notificare gli utenti connessi prima di un intervento di manutenzione, come terminare correttamente i processi e quale ruolo svolge il demone acpid<\/strong> nella gestione degli eventi ACPI.<\/p>\n
                                            Concetti principali<\/h3>\n
                                              \n
                                            • Hai compreso il significato dei runlevel<\/strong> nei sistemi basati su SysVinit.<\/li>\n
                                            • Hai imparato che systemd<\/strong> sostituisce i runlevel con i target<\/strong>.<\/li>\n
                                            • Hai imparato a visualizzare e modificare il target di avvio predefinito utilizzando systemctl get-default<\/code> e systemctl set-default<\/code>.<\/li>\n
                                            • Hai compreso la differenza tra la modifica permanente del target e il cambio temporaneo mediante systemctl isolate<\/code>.<\/li>\n
                                            • Hai utilizzato i principali comandi per arrestare, spegnere e riavviare un sistema Linux.<\/li>\n
                                            • Hai imparato a utilizzare il comando wall<\/code> per inviare messaggi a tutti gli utenti connessi.<\/li>\n
                                            • Hai compreso l’importanza di terminare i processi in modo ordinato utilizzando kill<\/code> prima di ricorrere a kill -9<\/code>.<\/li>\n
                                            • Hai conosciuto il ruolo del demone acpid<\/strong> nella gestione degli eventi ACPI.<\/li>\n<\/ul>\n
                                              \n
                                              \ud83c\udfaf Obiettivo raggiunto<\/strong> Al termine di questa lezione sei in grado di gestire i principali stati operativi di un sistema Linux, amministrare correttamente l’avvio e l’arresto del sistema, modificare i target di systemd e utilizzare gli strumenti fondamentali per la gestione di processi e utenti durante le operazioni di manutenzione.<\/p>\n<\/blockquote>\n
                                              Comandi da ricordare<\/h3>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
                                              Comando<\/th>\nDescrizione<\/th>\n<\/tr>\n<\/thead>\n
                                              systemctl get-default<\/code><\/td>\nVisualizza il target di avvio predefinito.<\/td>\n<\/tr>\n
                                              systemctl set-default target<\/code><\/td>\nImposta il target utilizzato ai successivi avvii.<\/td>\n<\/tr>\n
                                              systemctl isolate target<\/code><\/td>\nPassa immediatamente a un diverso target.<\/td>\n<\/tr>\n
                                              shutdown -h now<\/code><\/td>\nArresta e spegne il sistema.<\/td>\n<\/tr>\n
                                              shutdown -r now<\/code><\/td>\nRiavvia immediatamente il sistema.<\/td>\n<\/tr>\n
                                              systemctl poweroff<\/code><\/td>\nSpegne il sistema utilizzando systemd.<\/td>\n<\/tr>\n
                                              systemctl reboot<\/code><\/td>\nRiavvia il sistema utilizzando systemd.<\/td>\n<\/tr>\n
                                              telinit 1<\/code><\/td>\nPassa al runlevel 1 nei sistemi SysVinit.<\/td>\n<\/tr>\n
                                              wall<\/code><\/td>\nInvia un messaggio a tutti gli utenti connessi.<\/td>\n<\/tr>\n
                                              kill PID<\/code><\/td>\nInvia il segnale SIGTERM per terminare correttamente un processo.<\/td>\n<\/tr>\n
                                              kill -9 PID<\/code><\/td>\nForza la terminazione immediata di un processo (SIGKILL).<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
                                              \n
                                              \ud83d\udca1 Preparazione all’esame LPIC-1<\/strong> Prima di proseguire assicurati di conoscere la differenza tra runlevel<\/strong> e target<\/strong>, di saper distinguere i comandi systemctl isolate<\/code> e systemctl set-default<\/code> e di sapere quando utilizzare shutdown<\/code>, reboot<\/code>, wall<\/code> e kill<\/code>. Questi argomenti sono frequentemente presenti nelle domande della certificazione LPIC-1 Exam 101.<\/p>\n<\/blockquote>\n
                                              \n
                                              \u00a0<\/p>\n","protected":false},"comment_status":"open","ping_status":"closed","template":"","class_list":["post-3619","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.3 Cambiare i runlevel, i target di avvio e arrestare o riavviare il sistema Dopo aver compreso il processo di avvio di Linux, \u00e8 importante conoscere come il sistema gestisce i diversi stati operativi e come amministrare correttamente le operazioni di avvio, arresto e riavvio. Nelle distribuzioni Linux moderne il tradizionale concetto di runlevel, introdotto…","_links":{"self":[{"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/lesson\/3619","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=3619"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/media\/3666"}],"wp:attachment":[{"href":"https:\/\/rootmail.it\/en\/wp-json\/wp\/v2\/media?parent=3619"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}