Cap. 9. Sfaturi privind sistemul

# Cap. 9. Sfaturi privind sistemul

Aici, descriu sfaturi de bază pentru configurarea și gestionarea sistemelor, în principal din consolă.

## 9.1. Sfaturi pentru consolă

Există câteva programe utilitare care vă ajută în activitățile cu consola.

Tabel 9.1. Lista programelor ce ajută în activitățile cu consola

pachet | popcon(popularitate) | dimensiune | descriere
--- | --- | --- | ---
`mc` | V:43, I:183 | 1590 | consultați Secțiune 1.3, „Midnight Commander (MC)”
`bsdutils` | V:439, I:999 | 335 | `script`(1) comandă pentru înregistrarea sesiunii terminalului
`screen` | V:54, I:199 | 1006 | multiplexor de terminal cu emulare de terminal VT100/ANSI
`tmux` | V:79, I:153 | 1292 | alternativă multiplexor de terminal (utilizați «Control-B» în loc de acesta)
`fzf` | V:8, I:31 | 4651 | căutare text aproximativ
`fzy` | V:0, I:0 | 59 | căutare text aproximativ
`rlwrap` | V:1, I:12 | 328 | învăluitor de linie de comandă pentru funcționalitatea readline
`ledit` | V:0, I:8 | 375 | învăluitor de linie de comandă pentru funcționalitatea readline
`rlfe` | V:0, I:0 | 45 | învăluitor de linie de comandă pentru funcționalitatea readline
`ripgrep` | V:9, I:30 | 5342 | căutare rapidă recursivă de șiruri în arborele codului sursă cu filtrare automată

### 9.1.1. Înregistrarea activităților shell în mod curat

Utilizarea simplă a `script`(1) (vezi Secțiune 1.4.9, „Înregistrarea activităților shell-ului”) pentru a înregistra activitatea shell-ului produce un fișier cu caractere de control. Acest lucru poate fi evitat utilizând `col`(1) după cum urmează.

    $ script
    Script started, file is typescript

Faceți orice ... și apăsați `Ctrl-D` pentru a ieși din `script`.

    $ col -bx < typescript > cleanedfile
    $ vim cleanedfile

Există metode alternative pentru înregistrarea activităților din shell:

- Utilizați `tee` (utilizabil în timpul procesului de pornire din initramfs):

      $ sh -i 2>&1 | tee typescript

- Utilizați `gnome-terminal` cu tamponul de linie extins pentru derulare înapoi.

- Utilizați `screen` cu „`^A H`” (consultați Secțiune 9.1.2, „Programul «screen»”) pentru a efectua înregistrarea consolei.

- Utilizați `vim` cu „`:terminal`” pentru a intra în modul terminal. Utilizați „`Ctrl-W N`” pentru a ieși din modul terminal și a reveni la modul normal. Utilizați „`:w typescript`” pentru a scrie conținutul memoriei tampon într-un fișier.

- Utilizați `emacs` cu „`M-x shell`”, „`M-x eshell`” sau „`M-x term`” pentru a intra în consola de înregistrare. Utilizați „`C-x C-w`” pentru a scrie conținutul memoriei tampon într-un fișier.

### 9.1.2. Programul «screen»

`screen`(1) nu numai că permite unei ferestre de terminal să lucreze cu mai multe procese, dar permite și procesului shell de la distanță să supraviețuiască conexiunilor întrerupte. Iată un scenariu tipic de utilizare a `screen`(1).

1. Vă conectați la o mașină de la distanță.

2. Porniți `screen` pe o singură consolă.

3. Executați mai multe programe în ferestrele `screen` create cu `^A c` («Control-A» urmat de «c»).

4. Comutați între mai multe ferestre `screen` folosind comanda `^A n` («Control-A» urmat de «n»).

5. Dintr-o dată trebuie să părăsiți terminalul, dar nu doriți să pierdeți munca activă menținând conexiunea.

6. Puteți detașa sesiunea `screen` prin orice metodă.

   - Deconectați brutal conexiunea la rețea

   - Tastați `^A d` («Control-A» urmat de «d») și deconectați-vă manual de la conexiunea de la distanță

   - Tastați `^A DD` («Control-A» urmat de «DD») pentru a detașa `screen` și a vă deconecta

7. Vă conectați din nou la aceeași mașină de la distanță (chiar și de la un terminal diferit).

8. Porniți `screen` ca „`screen -r`”.

9. `screen` reatașează în mod magic toate ferestrele `screen` anterioare cu toate programele care rulează în mod activ.

| Indicație
Puteți economisi costurile de conectare cu `screen` pentru conexiunile de rețea contorizate, cum ar fi cele dial-up și cele pe pachete, deoarece puteți lăsa un proces activ în timp ce sunteți deconectat și apoi îl puteți reatașa mai târziu, când vă conectați din nou.

Într-o sesiune `screen`, toate introducerile de la tastatură sunt trimise către fereastra curentă, cu excepția tastelor de comandă. Toate tastele de comandă `screen` sunt introduse tastând `^A` («Control-A») plus o singură tastă [plus orice parametri]. Iată câteva dintre cele mai importante de reținut.

Tabel 9.2. Lista combinațiilor de taste pentru «screen»

comanda/funcția asociată | semnificație
--- | ---
`^A ?` | afișează un ecran de ajutor (afișează combinațiile de taste)
`^A c` | crează o fereastră nouă și comută la ea
`^A n` | trece la fereastra următoare
`^A p` | trece la fereastra anterioară
`^A 0` | trece la fereastra numărul 0
`^A 1` | trece la fereastra numărul 1
`^A w` | afișează o listă de ferestre
`^A a` | trimite «Ctrl-A» către fereastra curentă ca intrare de la tastatură
`^A h` | scrie o copie fizică a ferestrei curente într-un fișier
`^A H` | începe/încheie înregistrarea ferestrei curente în fișier
`^A ^X` | blochează terminalul (protejat cu parolă)
`^A d` | detașează sesiunea «screen» de terminal
`^A DD` | detașează sesiunea «screen» și termină sesiunea

Pentru detalii, consultați `screen`(1).

Consultați `tmux`(1) pentru funcționalitățile comenzii alternative.

### 9.1.3. Navigarea între directoare

În Secțiune 1.4.2, „Personalizarea bash” sunt descrise două sfaturi care permit navigarea rapidă între directoare: `$CDPATH` și `mc`.

Dacă utilizați un program de filtrare a textului aproximativ, puteți renunța la introducerea rutei exacte. Pentru `fzf`, includeți următoarele în `~/.bashrc`.

    FZF_KEYBINDINGS_PATH=/usr/share/doc/fzf/examples/key-bindings.bash
    if [ -f $FZF_KEYBINDINGS_PATH ]; then
      . $FZF_KEYBINDINGS_PATH
    fi

De exemplu:

- Puteți salta într-un subdirector foarte adânc cu eforturi minime. Mai întâi tastați „`cd **`” și apăsați `Tab`. Apoi vi se vor afișa rutele candidate. Tastând șiruri parțiale de rută, de exemplu, `s/d/b foo`, veți restrânge rutele candidate. Selectați ruta care va fi utilizată de `cd` cu ajutorul tastelor cursor și «Enter».

- Puteți selecta o comandă din istoricul comenzilor mai eficient, cu eforturi minime. Apăsați `Ctrl-R` la promptul de comandă. Apoi vi se vor afișa comenzile candidate. Tastând șiruri parțiale de comenzi, de exemplu `vim d`, veți restrânge numărul de comenzi candidate. Selectați comanda dorită cu ajutorul cursorului și tastelor de returnare.

### 9.1.4. Readline wrapper (învăluitorul «readline»)

Unele comenzi, cum ar fi `/usr/bin/dash`, care nu dispun de funcția de editare a istoricului liniei de comandă, pot adăuga această funcționalitate în mod transparent prin rularea sub `rlwrap` sau echivalenții săi.

     $ rlwrap dash -i

Aceasta oferă o platformă convenabilă pentru testarea punctelor subtile pentru `dash` într-un mediu prietenos, similar cu `bash`.

### 9.1.5. Scanarea arborelui codului sursă

Comanda `rg`(1) din pachetul `ripgrep` oferă o alternativă mai rapidă la comanda `grep`(1) pentru scanarea arborelui codului sursă în situații tipice. Aceasta profită de avantajele procesoarelor moderne multi-core și aplică automat filtre rezonabile pentru a omite anumite fișiere.

## 9.2. Personalizarea vim

După ce învățați noțiunile de bază ale `vim`(1) prin Secțiune 1.4.8, „Utilizarea editorului vim”, vă rugăm să citiți articolul lui Bram Moolenaar „Seven habits of effective text editing (2000)” (Șapte obiceiuri pentru o editare eficientă a textului) pentru a înțelege cum trebuie utilizat `vim`.

### 9.2.1. Personalizarea vim cu caracteristicile interne

Comportamentul `vim` poate fi modificat semnificativ prin activarea caracteristicilor sale interne prin intermediul comenzilor `Ex`-mode, cum ar fi „`set ...`” pentru a defini opțiunile vim.

Aceste comenzi în modul `Ex` pot fi incluse în fișierul vimrc al utilizatorului, tradiționalul „`~/.vimrc`” sau „`~/.vim/vimrc`”, compatibil cu git. Iată un exemplu foarte simplu [2]:

    """ Generic baseline Vim and Neovim configuration (~/.vimrc)
    """   - For NeoVim, use "nvim -u ~/.vimrc [filename]"
    """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
    let mapleader = ' '             " :h mapleader
    """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
    set nocompatible                " :h 'cp -- sensible (n)vim mode
    syntax on                       " :h :syn-on
    filetype plugin indent on       " :h :filetype-overview
    set encoding=utf-8              " :h 'enc (default: latin1) -- sensible encoding
    """ current vim option value can be verified by :set encoding?
    set backspace=indent,eol,start  " :h 'bs (default: nobs) -- sensible BS
    set statusline=%<%f%m%r%h%w%=%y[U+%04B]%2l/%2L=%P,%2c%V
    set listchars=eol:¶,tab:⇄\ ,extends:↦,precedes:↤,nbsp:␣
    set viminfo=!,'100,<5000,s100,h " :h 'vi -- bigger copy buffer etc.
    """ Pick "colorscheme" from blue darkblue default delek desert elflord evening
    """ habamax industry koehler lunaperche morning murphy pablo peachpuff quiet ron
    """ shine slate torte zellner
    colorscheme industry
    """ don't pick "colorscheme" as "default" which may kill SpellUnderline settings
    set scrolloff=5                 " :h 'scr -- show 5 lines around cursor
    set laststatus=2                " :h 'ls (default 1)  k
    """ boolean options can be unset by prefixing "no"
    set ignorecase                  " :h 'ic
    set smartcase                   " :h 'scs
    set autoindent                  " :h 'ai
    set smartindent                 " :h 'si
    set nowrap                      " :h 'wrap
    "set list                        " :h 'list (default nolist)
    set noerrorbells                " :h 'eb
    set novisualbell                " :h 'vb
    set t_vb=                       " :h 't_vb -- termcap visual bell
    set spell                       " :h 'spell
    set spelllang=en_us,cjk         " :h 'spl -- english spell, ignore CJK
    set clipboard=unnamedplus       " :h 'cb -- cut/copy/paste with other app
    set hidden                      " :h 'hid
    set autowrite                   " :h 'aw
    set timeoutlen=300              " :h 'tm

Harta tastelor din `vim` poate fi modificată în fișierul vimrc al utilizatorului. De exemplu:

| Atenție
Nu încercați să modificați combinațiile de taste implicite fără motive întemeiate.

    """ Popular mappings (imitating LazyVim etc.)
    """ Window moves without using CTRL-W which is dangerous in INSERT mode
    nnoremap <C-H> <C-W>h
    nnoremap <C-J> <C-W>j
    nnoremap <C-K> <C-W>k
    silent! nnoremap <C-L> <C-W>l
    """ Window resize
    nnoremap <C-LEFT> <CMD>vertical resize -2<CR>
    nnoremap <C-DOWN> <CMD>resize -2<CR>
    nnoremap <C-UP> <CMD>resize +2<CR>
    nnoremap <C-RIGHT> <CMD>vertical resize +2<CR>
    """ Clear hlsearch with <ESC> (<C-L> is mapped as above)
    nnoremap <ESC> <CMD>noh<CR><ESC>
    inoremap <ESC> <CMD>noh<CR><ESC>
    """ center after jump next
    nnoremap n nzz
    nnoremap N Nzz
    """ fast "jk" to get out of INSERT mode (<ESC>)
    inoremap  jk <CMD>noh<CR><ESC>
    """ fast "<ESC><ESC>" to get out of TERM mode (CTRL-\ CTRL-N)
    tnoremap <ESC><ESC> <C-\><C-N>
    """ fast "jk" to get out of TERM mode (CTRL-\ CTRL-N)
    tnoremap jk <C-\><C-N>
    """ previous/next trouble/quickfix item
    nnoremap [q <CMD>cprevious<CR>
    nnoremap ]q <CMD>cnext<CR>
    """ buffers
    nnoremap <S-H> <CMD>bprevious<CR>
    nnoremap <S-L> <CMD>bnext<CR>
    nnoremap [b <CMD>bprevious<CR>
    nnoremap ]b <CMD>bnext<CR>
    """ Add undo break-points
    inoremap  , ,<C-G>u
    inoremap  . .<C-G>u
    inoremap  ; ;<C-G>u
    """ save file
    inoremap <C-S> <CMD>w<CR><ESC>
    xnoremap <C-S> <CMD>w<CR><ESC>
    nnoremap <C-S> <CMD>w<CR><ESC>
    snoremap <C-S> <CMD>w<CR><ESC>
    """ better indenting
    vnoremap < <gv
    vnoremap > >gv
    """ terminal (Somehow under Linux, <C-/> becomes <C-_> in Vim)
    nnoremap <C-_> <CMD>terminal<CR>
    "nnoremap <C-/> <CMD>terminal<CR>
    """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
    if ! has('nvim')
    """ Toggle paste mode with <SPACE>p for Vim (no need for Nvim)
    set pastetoggle=<leader>p
    """ nvim default mappings for Vim.  See :h default-mappings in nvim
    """ copy to EOL (no delete) like D for d
    noremap Y y$
    """ sets a new undo point before deleting
    inoremap <C-U> <C-G>u<C-U>
    inoremap <C-W> <C-G>u<C-W>
    """ <C-L> is re-purposed as above
    """ execute the previous macro recorded with Q
    nnoremap Q @@
    """ repeat last substitute and *KEEP* flags
    nnoremap & :&&<CR>
    """ search visual selected string for visual mode
    xnoremap * y/\V<C-R>"<CR>
    xnoremap # y?\V<C-R>"<CR>
    endif

Pentru ca combinațiile de taste de mai sus să funcționeze corect, programul de terminal trebuie configurat să genereze „ASCII DEL” pentru tasta `Backspace` și „Secvență de eludare” pentru tasta `Delete`.

Alte configurații diverse pot fi modificate în fișierul vimrc al utilizatorului. De exemplu:

    """ Use faster 'rg' (ripgrep package) for :grep
    if executable("rg")
      set grepprg=rg\ --vimgrep\ --smart-case
      set grepformat=%f:%l:%c:%m
    endif
    """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
    """ Retain last cursor position :h '"
    augroup RetainLastCursorPosition
      autocmd!
      autocmd BufReadPost *
        \ if line("'\"") > 0 && line ("'\"") <= line("$") |
        \   exe "normal! g'\"" |
        \ endif
    augroup END
    """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
    """ Force to use underline for spell check results
    augroup SpellUnderline
      autocmd!
      autocmd ColorScheme * highlight SpellBad term=Underline gui=Undercurl
      autocmd ColorScheme * highlight SpellCap term=Underline gui=Undercurl
      autocmd ColorScheme * highlight SpellLocal term=Underline gui=Undercurl
      autocmd ColorScheme * highlight SpellRare term=Underline gui=Undercurl
    augroup END
    """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
    """ highlight tailing spaces except when typing as red (set after colorscheme)
    highlight TailingWhitespaces ctermbg=red guibg=red
    """ \s\+     1 or more whitespace character: <Space> and <Tab>
    """ \%#\@<!  Matches with zero width if the cursor position does NOT match.
    match TailingWhitespaces /\s\+\%#\@<!$/

### 9.2.2. Personalizarea vim cu pachete externe

Se pot găsi pachete de module de extensii externe interesante:

- Vim - the ubiquitous text editor -- Situl oficial al Vim și scripturilor vim

- VimAwsome -- Lista modulelor de extensie Vim

- vim-scripts -- Pachet Debian: o colecție de scripturi vim

Pachetele de module de extensie din pacheul vim-scripts pot fi activate folosind fișierul vimrc al utilizatorului. De exemplu:

    packadd! secure-modelines
    packadd! winmanager
    " IDE-like UI for files and buffers with <space>w
    nnoremap <leader>w         :WMToggle<CR>

Noul sistem nativ de pachete Vim funcționează bine cu „`git`” și „`git submodule`”. Un astfel de exemplu de configurare poate fi găsit în depozitul meu git: dot-vim. Acesta face în esență următoarele:

- Folosind „`git`” și „`git submodule`”, cele mai recente pachete externe, precum „`nume`”, sunt plasate în `~/.vim/pack/*/opt/nume` și similare.

- Prin adăugarea liniei `:packadd! nume` în fișierul vimrc al utilizatorului, aceste pachete sunt plasate în `runtimepath`.

- Vim încarcă aceste pachete în `runtimepath` în timpul inițializării.

- La finalul inițializării, etichetele pentru documentele instalate sunt actualizate cu „`helptags ALL`”.

Pentru mai multe informații, porniți `vim` cu „`vim --startuptime vimstart.log`” pentru a verifica secvența reală de execuție și timpul utilizat pentru fiecare etapă.

Este destul de confuz să vezi prea multe modalități[3] de a gestiona și încărca aceste pachete externe în `vim`. Verificarea informațiilor originale este cea mai bună soluție.

Tabel 9.3. Informații despre inițializarea `vim`

combinația de taste | informații
--- | ---
`:help package` | explicație privind mecanismul pachetului vim
`:help runtimepath` | explicație privind mecanismul `runtimepath`
`:version` | stări interne, inclusiv candidați pentru fișierul vimrc
`:echo $VIM` | variabila de mediu „`$VIM`” utilizată pentru localizarea fișierului vimrc
`:set runtimepath?` | lista directoarelor care vor fi căutate pentru toate fișierele de suport pentru rulare
`:echo $VIMRUNTIME` | variabila de mediu „`$VIMRUNTIME`” utilizată pentru localizarea diverselor fișiere de suport pentru rulare furnizate de sistem

## 9.3. Înregistrarea și prezentarea datelor

### 9.3.1. Demonul de jurnalizare

Multe programe tradiționale înregistrează activitățile lor în format fișier text în directorul „`/var/log/`”.

`logrotate`(8) este utilizat pentru a simplifica administrarea fișierelor jurnal pe un sistem care generează o mulțime de fișiere jurnal.

Multe programe noi își înregistrează activitățile în formatul de fișier binar utilizând serviciul de jurnal `systemd-journald`(8) în directorul „`/var/log/journal`”.

Puteți înregistra date în jurnalul `systemd-journald`(8) dintr-un script shell utilizând comanda `systemd-cat`(1).

Consultați Secțiune 3.5, „Mesajele sistemului” și Secțiune 3.4, „Mesajele nucleului”.

### 9.3.2. Analizator de jurnale

Iată câteva analizatoare de jurnale notabile („`~Gsecurity::log-analyzer`” în `aptitude`(8)).

Tabel 9.4. Lista analizatoarelor de jurnale de sistem

pachet | popcon(popularitate) | dimensiune | descriere
--- | --- | --- | ---
`logwatch` | V:9, I:10 | 2435 | analizator de jurnale cu ieșire formatată plăcut, scris în Perl
`fail2ban` | V:95, I:106 | 2191 | interzice adresele IP care provoacă erori multiple de autentificare
`analog` | V:3, I:88 | 3739 | analizator de jurnale de server web
`awstats` | V:5, I:8 | 6935 | analizator de jurnale de server web, performant și cu multe funcții
`sarg` | V:0, I:0 | 863 | generator de rapoarte de analizare squid
`pflogsumm` | V:1, I:3 | 170 | program de sinteză a intrărilor din jurnalul Postfix
`fwlogwatch` | V:0, I:0 | 487 | analizator de jurnale de paravan de protecție
`squidview` | V:0, I:0 | 189 | monitorizează și analizează fișierele squid access.log
`swatch` | V:0, I:0 | 99 | vizor de fișiere jurnal cu potrivire de expresii regulate, evidențiere și cârlige
`crm114` | V:0, I:0 | 1371 | Filtru de spam și filtru cu expresii regulate controlabile („Controllable Regex Mutilator”: CRM114)
`icmpinfo` | V:0, I:0 | 42 | interpretează mesajele ICMP

| Notă
CRM114 oferă infrastructura lingvistică necesară pentru a scrie filtre fuzzy (aproximative) cu ajutorul bibliotecii TRE regex. Este utilizat în mod obișnuit pentru filtrarea mesajelor spam, dar poate fi folosit și ca analizor de jurnale.

### 9.3.3. Afișarea personalizată a datelor textuale

Deși instrumentele de paginare precum `more`(1) și `less` (1) (a se vedea Secțiune 1.4.5, „Paginatorul”) și instrumentele personalizate pentru evidențiere și formatare (a se vedea Secțiune 11.1.8, „Highlighting and formatting plain text data”) pot afișa datele de text într-un mod plăcut, editorii de uz general (a se vedea Secțiune 1.4.6, „Editorul de text”) sunt cei mai versatili și cei care pot fi cel mai mult personalizați.

| Indicație
Pentru `vim`(1) și pseudonimul său pentru modul de paginator `view`(1), „`:set hls`” activează căutarea evidențiată.

### 9.3.4. Afișare personalizată a orei și datei

Formatul implicit de afișare a orei și datei de către comanda „`ls -l`” depinde de configurația regională (vedeți Secțiune 1.2.6, „Marcaje de timp” pentru valoare). Variabila „`$LANG`” este consultată prima și poate fi suprascrisă de variabilele de mediu exportate „`$LC_TIME`” sau „`$LC_ALL`”.

Formatul de afișare implicit pentru fiecare configurație regională depinde de versiunea bibliotecii standard C (pachetul `libc6`) utilizată. Adică, versiunile diferite ale Debian aveau configurații implicite diferite. Pentru formatele iso, consultați ISO 8601.

Dacă doriți cu adevărat să personalizați acest format de afișare a datei și orei dincolo de configurația regională, trebuie să definiți valoarea stilului de afișare a datei și orei prin argumentul „`--time-style`” sau prin valoarea „`$TIME_STYLE`” (consultați `ls`(1), `date`(1), «`info coreutils 'ls invocation'`»).

Tabel 9.5. Exemplele de afișare a datei și orei pentru comanda „`ls -l`” cu valoarea stilului de afișare a datei și orei

valoarea stilului de afișare a datei și orei | configurația regională | afișarea datei și orei
--- | --- | ---
`iso` | oricare | `01-19 00:15`
`long-iso` | oricare | `2009-01-19 00:15`
`full-iso` | oricare | `2009-01-19 00:15:16.000000000 +0900`
`locale` | `C` | `Jan 19 00:15`
`locale` | `en_US.UTF-8` | `Jan 19 00:15`
`locale` | `es_ES.UTF-8` | `ene 19 00:15`
`+%d.%m.%y %H:%M` | oricare | `19.01.09 00:15`
`+%d.%b.%y %H:%M` | `C` sau `en_US.UTF-8` | `19.Jan.09 00:15`
`+%d.%b.%y %H:%M` | `es_ES.UTF-8` | `19.ene.09 00:15`

| Indicație

Puteți elimina introducerea opțiunilor lungi în linia de comandă utilizând un alias de comandă (consultați Secțiune 1.5.9, „Alias de comandă”):

    alias ls='ls --time-style=+%d.%m.%y %H:%M'

### 9.3.5. Ecou colorat al shell-ului

Ecoul Shell pentru majoritatea terminalelor moderne poate fi colorat folosind codul de eludare ANSI (vedeți „`/usr/share/doc/xterm/ctlseqs.txt.gz`”).

De exemplu, încercați următoarele

    $ RED=$(printf "\x1b[31m")
    $ NORMAL=$(printf "\x1b[0m")
    $ REVERSE=$(printf "\x1b[7m")
    $ echo "${RED}RED-TEXT${NORMAL} ${REVERSE}REVERSE-TEXT${NORMAL}"

### 9.3.6. Comenzi colorate

Comenzile colorate sunt utile pentru inspectarea rezultatelor acestora în mediul interactiv. Includ următoarele în fișierul meu „`~/.bashrc`”.

    if [ "$TERM" != "dumb" ]; then
        eval "`dircolors -b`"
        alias ls='ls --color=always'
        alias ll='ls --color=always -l'
        alias la='ls --color=always -A'
        alias less='less -R'
        alias ls='ls --color=always'
        alias grep='grep --color=always'
        alias egrep='egrep --color=always'
        alias fgrep='fgrep --color=always'
        alias zgrep='zgrep --color=always'
    else
        alias ll='ls -l'
        alias la='ls -A'
    fi

Utilizarea unui alias limitează efectele de culoare la utilizarea interactivă a comenzii. Are avantajul față de exportarea variabilei de mediu „`export GREP_OPTIONS='--color=auto'`”, deoarece culoarea poate fi văzută în programele de paginare, cum ar fi `less`(1). Dacă doriți să suprimați culoarea atunci când redirecționați către alte programe, utilizați „`--color=auto`” în locul exemplului de mai sus pentru „`~/.bashrc`”.

| Indicație
Puteți dezactiva aceste nume-alias de colorare în mediul interactiv apelând shell cu „`TERM=dumb bash`”.

### 9.3.7. Înregistrarea activităților editorului pentru repetări complexe

Puteți înregistra activitățile editorului pentru repetări complexe.

Pentru Vim, procedați după cum urmează.

- «`qa`»: începe înregistrarea caracterelor tastate în registrul numit „`a`”.

- … activități ale editorului

- «`q`»: încheie înregistrarea caracterelor tastate.

- «`@a`»: execută conținutul registrului „`a`”.

Pentru Emacs, procedați după cum urmează.

- «`C-x (`»: începe definirea unei macrocomenzi pentru tastatură.

- … activități ale editorului

- «`C-x )`»: încheie definirea macrocomenzii pentru tastatură.

- «`C-x e`»: execută o macrocomandă pentru tastatură.

### 9.3.8. Înregistrarea imaginii grafice a unei aplicații X

Există câteva modalități de a înregistra imaginea grafică a unei aplicații X, inclusiv un afișaj `xterm`.

Tabel 9.6. Lista instrumentelor de manipulare a imaginilor grafice

pachet | popcon(popularitate) | dimensiune | ecran | comanda
--- | --- | --- | --- | ---
`gnome-screenshot` | V:13, I:111 | 1115 | Wayland | aplicație de captură de ecran pentru GNOME
`flameshot` | V:7, I:17 | 3532 | Wayland | aplicație de captură de ecran cu steroizi
`gimp` | V:35, I:229 | 31748 | Wayland + X | captură de ecran în meniul interfeței grafice a aplicației
`x11-apps` | V:33, I:464 | 2461 | X | `xwd`(1)
`imagemagick` | I:290 | 77 | X | `import`(1)
`scrot` | V:4, I:53 | 141 | X | `scrot`(1)

### 9.3.9. Înregistrarea modificărilor din fișierele de configurare

Există instrumente specializate pentru înregistrarea modificărilor din fișierele de configurare cu ajutorul DVCS și pentru realizarea de instantanee ale sistemului pe Btrfs.

Tabel 9.7. Lista pachetelor care pot înregistra istoricul configurațiilor

pachet | popcon(popularitate) | dimensiune | descriere
--- | --- | --- | ---
`etckeeper` | V:24, I:27 | 157 | stochează fișierele de configurare și metadatele acestora cu Git (implicit), Mercurial sau GNU Bazaar
`timeshift` | V:7, I:13 | 4481 | utiilitate de restaurare a sistemului folosind rsync sau instantanee BTRFS
`snapper` | V:6, I:8 | 2410 | instrument de gestionare a instantaneelor sistemului de fișiere Linux

Puteți lua în considerare și abordarea scriptului local Secțiune 10.2.3, „Backup tips”.

## 9.4. Monitorizarea, controlul și inițierea activităților programului

Activitățile programului pot fi monitorizate și controlate folosind instrumente specializate.

Tabel 9.8. Lista instrumentelor pentru monitorizarea și controlul activităților programului

pachet | popcon(popularitate) | dimensiune | descriere
--- | --- | --- | ---
`coreutils` | V:892, I:999 | 18457 | `nice`(1): rulează un program cu prioritate de planificare modificată
`bsdutils` | V:439, I:999 | 335 | `renice`(1): modifică prioritatea de planificare a unui proces în execuție
`procps` | V:818, I:998 | 2404 | Utilități ale sistemului de fișiere „`/proc`”: `ps`(1), `top`(1), `kill`(1), `watch`(1), …
`psmisc` | V:410, I:742 | 950 | Utilități ale sistemului de fișiere „`/proc`”: `killall`(1), `fuser`(1), `peekfd`(1), `pstree`(1)
`time` | V:5, I:85 | 129 | `time`(1): rulează un program pentru a raporta utilizarea resurselor sistemului în funcție de timp
`sysstat` | V:123, I:162 | 1904 | `sar`(1), `iostat`(1), `mpstat`(1), …: instrumente de performanță a sistemului pentru Linux
`isag` | V:0, I:3 | 109 | Grafic interactiv al activității sistemului pentru sysstat
`lsof` | V:443, I:949 | 492 | `lsof`(8): listează fișierele deschise de un proces în execuție folosind opțiunea „`-p`”
`strace` | V:10, I:103 | 3253 | `strace`(1): urmărește apelurile de sistem și semnalele
`ltrace` | V:0, I:11 | 420 | `ltrace`(1): trasează apelurile către bibliotecă
`xtrace` | V:0, I:0 | 353 | `xtrace`(1): trasează comunicarea între clientul X11 și server
`powertop` | V:33, I:232 | 696 | `powertop`(1): informații despre consumul de energie al sistemului
`cron` | V:901, I:996 | 250 | rulează procesele conform unei programări în fundal din `cron`(8) daemon
`anacron` | V:418, I:493 | 112 | programator de comenzi de tip cron pentru sisteme care nu funcționează 24 de ore pe zi
`at` | V:74, I:102 | 158 | `at`(1) sau `batch`(1): execută o sarcină la o oră specificată sau sub un anumit nivel de încărcare

| Indicație
Pachetele `procps` oferă elementele de bază pentru monitorizarea, controlul și pornirea activităților programelor. Ar trebui să le învățați pe toate.

### 9.4.1. Cronometrarea unui proces

Afișează timpul utilizat de procesul invocat de comandă.

    # time some_command >/dev/null
    real    0m0.035s       # time on wall clock (elapsed real time)
    user    0m0.000s       # time in user mode
    sys     0m0.020s       # time in kernel mode

### 9.4.2. Prioritatea de planificare

O valoare potrivită(de curtoazie) este utilizată pentru a controla prioritatea de planificare a procesului.

Tabel 9.9. Lista valorilor de curtoazie pentru prioritatea de programare

valoarea de curtoazie | prioritatea de planificare
--- | ---
19 | proces cu prioritate minimă (nice - curtoazie)
0 | proces cu prioritate foarte mare pentru utilizator
-20 | proces cu prioritate foarte mare pentru root (fără curtoazie)

    # nice  -19 top                                      # very nice
    # nice --20 wodim -v -eject speed=2 dev=0,0 disk.img # very fast

Uneori, o valoare extrem de mare poate face mai mult rău decât bine sistemului. Utilizați această comandă cu precauție.

### 9.4.3. Comanda «ps»

Comanda `ps`(1) pe un sistem Debian acceptă atât caracteristicile BSD, cât și SystemV și ajută la identificarea statică a activității procesului.

Tabel 9.10. Lista stilurilor de comenzi ps

stil | comandă tipică | funcția
--- | --- | ---
BSD | `ps aux` | afișează %CPU %MEM
System V | `ps -efH` | afișează PPID

Procesele-copil zombie (inactive), le puteți opri utilizând ID-ul procesului părinte identificat în câmpul „`PPID`”.

Comanda `pstree`(1) afișează arborele proceselor.

### 9.4.4. Comanda «top»

`top`(1) în sistemul Debian are funcții bogate și ajută la identificarea proceselor care se comportă ciudat în mod dinamic.

Este un program interactiv pe ecran complet. Puteți obține ajutorul de utilizare apăsând tasta «h» și îl puteți închide apăsând tasta «q».

### 9.4.5. Listarea fișierelor deschise de un proces

Puteți lista toate fișierele deschise de un proces cu un ID de proces (PID), de exemplu 1, folosind următoarea comandă.

    $ sudo lsof -p 1

PID=1 este de obicei programul `init`.

### 9.4.6. Urmărirea activităților programului

Puteți urmări activitatea programului cu `strace`(1), `ltrace`(1) sau `xtrace`(1) pentru apeluri și semnale de sistem, apeluri de bibliotecă sau comunicarea între clientul și serverul X11.

Puteți urmări apelurile de sistem ale comenzii `ls` după cum urmează.

    $ sudo strace ls

| Indicație
Utilizați scriptul strace-graph din /usr/share/doc/strace/examples/ pentru a crea o vizualizare arborescentă plăcută

### 9.4.7. Identificarea proceselor care utilizează fișiere sau socluri

De asemenea, puteți identifica procesele utilizând fișiere prin `fuser`(1), de exemplu pentru „`/var/log/mail.log`” prin următoarea comandă.

    $ sudo fuser -v /var/log/mail.log
                         USER        PID ACCESS COMMAND
    /var/log/mail.log:   root       2946 F.... rsyslogd

Puteți vedea că fișierul „`/var/log/mail.log`” este deschis pentru scriere de comanda `rsyslogd`(8).

De asemenea, puteți identifica procesele care utilizează socluri cu ajutorul comenzii `fuser`(1), de exemplu pentru „`smtp/tcp`” cu ajutorul următoarei comenzi.

    $ sudo fuser -v smtp/tcp
                         USER        PID ACCESS COMMAND
    smtp/tcp:            Debian-exim   3379 F.... exim4

Acum știți că sistemul dvs. rulează `exim4`(8) pentru a gestiona conexiunile TCP la portul SMTP (25).

### 9.4.8. Repetarea unei comenzi la intervale constante

`watch`(1) execută un program în mod repetat, la intervale constante, afișând rezultatul pe ecranul complet.

    $ watch w

Afișează cine este conectat la sistem, actualizat la fiecare 2 secunde.

### 9.4.9. Repetarea unei comenzi care parcurge fișierele

Există mai multe moduri de a repeta o comandă care parcurge fișierele care corespund unei anumite condiții, de exemplu, care corespund modelului global (cu caracter joker) „`*.ext`”.

- Metoda Shell for-loop (a se vedea Secțiune 12.1.4, „Bucle shell”):

    for x in *.ext; do if [ -f "$x"]; then command "$x" ; fi; done

- combinația `find`(1) și `xargs`(1):

    find . -type f -maxdepth 1 -name '*.ext' -print0 | xargs -0 -n 1 command

- `find`(1) cu opțiunea „`-exec`” cu o comandă:

    find . -type f -maxdepth 1 -name '*.ext' -exec command '{}' \;

- `find`(1) cu opțiunea „`-exec`” cu un script shell scurt:

    find . -type f -maxdepth 1 -name '*.ext' -exec sh -c "command '{}' && echo 'successful'" \;

Exemplele de mai sus sunt scrise pentru a asigura gestionarea corectă a numelor de fișiere ciudate, cum ar fi cele care conțin spații. Consultați Secțiune 10.1.5, „Idioms for the selection of files” pentru utilizări mai avansate ale `find`(1).

### 9.4.10. Pornirea unui program din interfața grafică

Pentru interfața de linie de comandă („command-line interface”: CLI), se execută primul program cu numele corespunzător găsit în directoarele specificate în variabila de mediu `$PATH`. Consultați Secțiune 1.5.3, „Variabila „`$PATH`””.

Pentru interfața grafică cu utilizatorul („graphical user interface”: GUI) conformă cu standardele freedesktop.org, fișierele `*.desktop` din directorul `/usr/share/applications/` furnizează atributele necesare pentru afișarea meniului GUI al fiecărui program. Fiecare pachet care este compatibil cu sistemul de meniuri xdg al Freedesktop.org instalează datele de meniu furnizate de „*.desktop” în „/usr/share/applications/”. Mediile grafice de birou moderne care sunt compatibile cu standardul Freedesktop.org utilizează aceste date pentru a genera meniul lor folosind pachetul xdg-utils. Consultați „/usr/share/doc/xdg-utils/README”.

De exemplu, fișierul `chromium.desktop` definește atributele pentru „Navigatorul Web Chromium”, cum ar fi „Name” pentru numele programului, „Exec” pentru ruta de execuție și argumentele programului, „Icon” pentru pictograma utilizată etc. (consultați Descriptorul de intrare desktop) după cum urmează:

    [Desktop Entry]
    Version=1.0
    Name=Chromium Web Browser
    GenericName=Web Browser
    Comment=Access the Internet
    Comment[fr]=Explorer le Web
    Exec=/usr/bin/chromium %U
    Terminal=false
    X-MultipleArgs=false
    Type=Application
    Icon=chromium
    Categories=Network;WebBrowser;
    MimeType=text/html;text/xml;application/xhtml_xml;x-scheme-handler/http;x-scheme-handler/https;
    StartupWMClass=Chromium
    StartupNotify=true

Aceasta este o descriere simplificată. Fișierele `*.desktop` sunt scanate după cum urmează.

The desktop environment sets `$XDG_DATA_HOME` and `$XDG_DATA_DIR` environment variables. For example, under the GNOME:

- variabila `$XDG_DATA_HOME` nu este definită; (se utilizează valoarea implicită `$HOME/.local/share`)

- variabila `$XDG_DATA_DIRS` este definită ca `/usr/share/gnome:/usr/local/share/:/usr/share/`

Astfel, directoarele de bază (a se vedea XDG Base Directory Specification) și directoarele de `aplicații` sunt următoarele.

- `$HOME/.local/share/` → `$HOME/.local/share/applications/`

- `/usr/share/gnome/` → `/usr/share/gnome/applications/`

- `/usr/local/share/` → `/usr/local/share/applications/`

- `/usr/share/` → `/usr/share/applications/`

Fișierele `*.desktop` sunt scanate în aceste directoare de `aplicații` în această ordine.

| Indicație
O intrare personalizată în meniul GUI poate fi creată prin adăugarea unui fișier `*.desktop` în directorul `$HOME/.local/share/applications/`.

| Indicație
Linia „`Exec=...`” nu este analizată de shell. Utilizați comanda `env`(1) dacă trebuie să fie definite variabile de mediu.

| Indicație
În mod similar, dacă un fișier `*.desktop` este creat în directorul `autostart` din aceste directoare de bază, programul specificat în fișierul `*.desktop` este executat automat la pornirea mediului de birou. Consultați Desktop Application Autostart Specification.

| Indicație

În mod similar, dacă un fișier `*.desktop` este creat în directorul `$HOME/Desktop` și mediul grafic de birou este configurat să accepte funcția de lansare a pictogramelor de pe birou, programul specificat în acesta este executat la efectuarea unui clic cu mouse-ul pe pictogramă. Rețineți că numele real al directorului `$HOME/Desktop` depinde de configurația regională. Consultați `xdg-user-dirs-update`(1).

### 9.4.11. Personalizarea programului care urmează să fie pornit

Unele programe pornesc automat un alt program. Iată câteva puncte de verificare pentru personalizarea acestui proces.

- Meniul de configurare a aplicației:

  - GNOME desktop: "Settings" → "Apps" → "Default Apps"

  - KDE desktop: "Application Launcher" → "System Settings" → "Default Applications"

  - navigatorul web Iceweasel: «Editare» → «Preferințe» → «Aplicații»

  - `mc`(1): "`/etc/mc/mc.ext`"

- Variabile de mediu precum „`$BROWSER`”, „`$EDITOR`”, „`$VISUAL`” și „`$PAGER`” (a se vedea `environ`(7))

- Sistemul `update-alternatives`(1) pentru programe precum „`editor`”, „`view`”, „`x-www-browser`”, „`gnome-www-browser`” și „`www-browser`” (a se vedea Secțiune 1.4.7, „Definirea unui editor de text implicit”)

- Conținutul fișierelor „`~/.mailcap`” și „`/etc/mailcap`” care asociază tipul MIME cu programul (a se vedea `mailcap`(5))

- Conținutul fișierelor „`~/.mime.types`” și „`/etc/mime.types`” care asociază extensia numelui fișierului cu tipul MIME (a se vedea `run-mailcap`(1))

| Indicație
`update-mime`(8) actualizează fișierul „`/etc/mailcap`” folosind fișierul „`/etc/mailcap.order`” (a se vedea `mailcap.order`(5)).

| Indicație
Pachetul `debianutils` oferă `sensible-browser`(1), `sensible-editor`(1) și `sensible-pager`(1), care iau decizii rezonabile cu privire la editorul, paginatorul și navigatorul web care trebuie apelate. Vă recomand să citiți aceste scripturi shell.

| Indicație

Pentru a rula o aplicație de consolă precum `mutt` sub GUI ca aplicație preferată, trebuie să creați o aplicație cu interfață grafică după cum urmează și să definiți „`/usr/local/bin/mutt-term`” ca aplicație preferată care să fie pornită conform descrierii.

    # cat /usr/local/bin/mutt-term <<EOF
    #!/bin/sh
    gnome-terminal -e "mutt \$@"
    EOF
    # chmod 755 /usr/local/bin/mutt-term

### 9.4.12. Omorârea unui proces

Utilizați `kill`(1) pentru a omorî (sau a trimite un semnal către) un proces prin ID-ul procesului.

Utilizați `killall`(1) sau `pkill`(1) pentru a face același lucru folosind numele comenzii procesului și alte atribute.

Tabel 9.11. Lista semnalelor utilizate frecvent pentru comanda «kill»

valoare semnal | nume semnal | acțiunea | notă
--- | --- | --- | ---
0 | --- | nu se trimite niciun semnal (vedeți `kill`(2)) | verifică dacă procesul rulează
1 | SIGHUP | termină procesul | terminal deconectat (semnal de suspendare)
2 | SIGINT | termină procesul | întrerupere de la tastatură (`CTRL-C`)
3 | SIGQUIT | termină procesul și efectuează operația dump core (descarcă conținutul memoriei) | ieșire de la tastatură (`CTRL-\`)
9 | SIGKILL | termină procesul | semnal de omorâre de neblocat
15 | SIGTERM | termină procesul | semnal de terminare blocabil

### 9.4.13. Programarea sarcinilor o singură dată

Rulează comanda `at`(1) pentru a programa o sarcină unică după cum urmează.

    $ echo 'command -args'| at 3:40 monday

### 9.4.14. Programarea regulată a sarcinilor

Utilizați `cron`(8) pentru a programa sarcini în mod regulat. Consultați `crontab`(1) și `crontab`(5).

Puteți programa rularea proceselor ca utilizator normal, de exemplu `foo`, creând un fișier `crontab`(5) ca „`/var/spool/cron/crontabs/foo`” cu comanda „`crontab -e`”.

Iată un exemplu de fișier `crontab`(5).

    # use /usr/bin/sh to run commands, no matter what /etc/passwd says
    SHELL=/bin/sh
    # mail any output to paul, no matter whose crontab this is
    MAILTO=paul
    # Min Hour DayOfMonth Month DayOfWeek command (Day... are OR'ed)
    # run at 00:05, every day
    5  0  *  * *   $HOME/bin/daily.job >> $HOME/tmp/out 2>&1
    # run at 14:15 on the first of every month -- output mailed to paul
    15 14 1  * *   $HOME/bin/monthly
    # run at 22:00 on weekdays(1-5), annoy Joe. % for newline, last % for cc:
    0 22 *   * 1-5 mail -s "It's 10pm" joe%Joe,%%Where are your kids?%.%%
    23 */2 1 2 *   echo "run 23 minutes after 0am, 2am, 4am ..., on Feb 1"
    5  4 *   * sun echo "run at 04:05 every Sunday"
    # run at 03:40 on the first Monday of each month
    40 3 1-7 * *   [ "$(date +%a)" == "Mon" ] && command -args

| Indicație
Pentru ca sistemul să nu funcționeze continuu, instalați pachetul `anacron` pentru a programa comenzi periodice la intervale specificate, pe cât posibil în funcție de timpul de funcționare al mașinii. Consultați `anacron`(8) și `anacrontab`(5).

| Indicație
Pentru scripturile de întreținere programată a sistemului, le puteți rula periodic din contul root, plasând astfel de scripturi în „`/etc/cron.hourly/`”, „`/etc/cron.daily/`”, „`/etc/cron.weekly/`” sau „`/etc/cron.monthly/`”. Momentele de execuție ale acestor scripturi pot fi personalizate prin „`/etc/crontab`” și „`/etc/anacrontab`”.

Systemd are capacitatea de nivel inferior de a programa rularea programelor fără demonul `cron`. De exemplu, `/lib/systemd/system/apt-daily.timer` și `/lib/systemd/system/apt-daily.service` configurează activitățile zilnice de descărcare apt. Consultați `systemd.timer`(5) .

### 9.4.15. Programarea sarcinilor la eveniment

Systemd poate programa programul nu numai pe evenimentul cronometrat, ci și pe evenimentul de montare. Consultați Secțiune 10.2.3.3, „Timer event triggered backup” și Secțiune 10.2.3.2, „Mount event triggered backup” pentru exemple.

### 9.4.16. Tasta Alt-SysRq

Apăsarea tastelor Alt-SysRq (PrtScr) urmată de o singură tastă face minunea de a recupera controlul asupra sistemului.

Tabel 9.12. Lista tastelor de comandă SAK importante

tasta ce urmează după Alt-SysRq | descrierea acțiunii
--- | ---
`k` | kill (omoară) toate procesele din consola virtuală curentă (SAK)
`s` | sincronizează toate sistemele de fișiere montate pentru a evita coruperea datelor
`u` | remontează toate sistemele de fișiere montate în mod citire-numai (umount)
`r` | restabilește tastatura din modul raw (brut) după blocarea X

Vedeți mai multe în Linux kernel user’s and administrator’s guide » Linux Magic System Request Key Hacks

| Indicație
Din terminalul SSH etc., puteți utiliza funcția Alt-SysRq scriind în „`/proc/sysrq-trigger`”. De exemplu, „`echo s > /proc/sysrq-trigger; echo u > /proc/sysrq-trigger`” din promptul shell-ului root sincronizează și udemontează toate sistemele de fișiere montate.

Nucleul Linux Debian amd64 actual (2021) are `/proc/sys/kernel/sysrq=438=0b110110110`:

- 2 = 0x2 - activează controlul nivelului de înregistrare în jurnalul consolei (ACTIVAT)

- 4 = 0x4 - activează controlul tastaturii (SAK, unraw) (ACTIVAT)

- 8 = 0x8 - activează dump-urile de depanare ale proceselor etc. (DEZACTIVAT)

- 16 = 0x10 - activează comanda de sincronizare (ACTIVAT)

- 32 = 0x20 - activează remontarea numai pentru citire (ACTIVAT)

- 64 = 0x40 - activează semnalizarea proceselor (term, kill, oom-kill) (dezactivat)

- 128 = 0x80 - permite repornirea/oprirea (ACTIVAT)

- 256 = 0x100 - permite optimizarea tuturor sarcinilor RT (ACTIVAT)

## 9.5. Sfaturi pentru întreținerea sistemului

### 9.5.1. Cine este în sistem?

Puteți verifica cine este conectat la sistem urmând pașii de mai jos.

- `who` (1) arată cine este conectat.

- `w`(1) arată cine este conectat și ce face.

- `last`(1) afișează lista ultimilor utilizatori conectați.

- `lastb`(1) afișează lista ultimilor utilizatori care s-au conectat incorect.

| Indicație
„`/var/run/utmp`” și „`/var/log/wtmp`” conțin astfel de informații despre utilizatori. Consultați `login`(1) și `utmp`(5).

### 9.5.2. Avertisment pentru toată lumea

Puteți trimite mesaje tuturor celor care sunt conectați la sistem cu `wall`(1) în felul următor.

    $ echo "We are shutting down in 1 hour" | wall

### 9.5.3. Identificarea hardware-ului

Pentru dispozitivele de tip PCI (AGP, PCI-Express, CardBus, ExpressCard etc.), `lspci`(8) (probabil cu opțiunea „`-nn`”) este un bun punct de plecare pentru identificarea hardware-ului.

Alternativ, puteți identifica hardware-ul citind conținutul „`/proc/bus/pci/devices`” sau răsfoind arborele de directoare din „`/sys/bus/pci`” (consultați Secțiune 1.2.12, „procfs și sysfs”).

Tabel 9.13. Lista instrumentelor de identificare a hardware-ului

pachet | popcon(popularitate) | dimensiune | descriere
--- | --- | --- | ---
`pciutils` | V:254, I:992 | 280 | utilități PCI Linux: `lspci`(8)
`usbutils` | V:80, I:887 | 322 | utilități USB Linux: `lsusb`(8)
`nvme-cli` | V:22, I:30 | 2222 | utilități NVMe pentru Linux: `nvme`(1)
`pcmciautils` | V:4, I:7 | 92 | utilități PCMCIA pentru Linux: `pccardctl`(8)
`scsitools` | V:0, I:2 | 261 | colecție de instrumente pentru gestionarea hardware-ului SCSI: `lsscsi`(8)
`procinfo` | V:0, I:6 | 149 | informații despre sistem obținute din „`/proc`”: `lsdev`(8)
`lshw` | V:13, I:90 | 971 | informații despre configurația hardware: `lshw`(1)
`discover` | V:27, I:685 | 81 | sistem de identificare hardware: `discover` (8)

### 9.5.4. Configurația hardware

Deși majoritatea configurațiilor hardware ale sistemelor grafice de birou moderne, precum GNOME și KDE, pot fi gestionate prin intermediul instrumentelor de configurare grafice însoțitoare, este recomandabil să cunoașteți câteva metode de bază pentru configurarea acestora.

Tabel 9.14. Lista instrumentelor de configurare hardware

pachet | popcon(popularitate) | dimensiune | descriere
--- | --- | --- | ---
`console-setup` | V:77, I:973 | 420 | utilități pentru fonturi și tabele de taste pentru consola Linux
`x11-xserver-utils` | V:312, I:542 | 559 | utilități server X: `xset`(1), `xmodmap`(1)
`acpid` | V:58, I:90 | 158 | demon pentru gestionarea evenimentelor transmise de Interfața avansată de configurare și alimentare (ACPI)
`acpi` | V:7, I:85 | 49 | instrument pentru afișarea informațiilor despre dispozitivele ACPI
`sleepd` | V:0, I:0 | 84 | demon pentru a pune laptopul în stare de repaus în timpul inactivității
`hdparm` | V:117, I:222 | 246 | optimizarea accesului la discurile dure (a se vedea Secțiune 9.6.9, „Optimizarea discului dur”)
`smartmontools` | V:229, I:264 | 2455 | control and monitor storage systems using S.M.A.R.T.
`setserial` | V:3, I:5 | 104 | colecție de instrumente pentru gestionarea porturilor seriale
`memtest86+` | V:0, I:19 | 12473 | colecție de instrumente pentru gestionarea hardware-ului de memorie
`scsitools` | V:0, I:2 | 261 | colecție de instrumente pentru gestionarea hardware-ului SCSI
`setcd` | V:0, I:0 | 33 | optimizarea accesului la unitatea de disc compact
`big-cursor` | I:0 | 26 | cursoare de mouse mai mari pentru X

Aici, ACPI este un cadru mai nou pentru sistemul de gestionare a energiei decât APM.

| Indicație
Scalarea frecvenței procesorului pe sistemele moderne este controlată de module ale nucleului, precum `acpi_cpufreq`.

### 9.5.5. Ora sistemului și ora hardware-ului

Următoarele stabilesc ora sistemului și a hardware-ului la MM/DD hh:mm, CCYY.

    # date MMDDhhmmCCYY
    # hwclock --utc --systohc
    # hwclock --show

Ora este afișată în mod normal în ora locală pe sistemul Debian, dar hardware-ul și ora sistemului utilizează de obicei UTC(GMT).

Dacă ora hardware este stabilită la UTC, modificați configurația la „`UTC=yes`” în „`/etc/default/rcS`”.

Următoarele reconfigurează fusul orar utilizat de sistemul Debian.

    # dpkg-reconfigure tzdata

Dacă doriți să actualizați ora sistemului prin rețea, luați în considerare utilizarea serviciului NTP cu pachete precum `ntp`, `ntpdate` și `chrony`.

| Indicație
În systemd, utilizați în schimb `systemd-timesyncd` pentru sincronizarea orei în rețea. Consultați `systemd-timesyncd`(8).

Consultați următoarele.

- Managing Accurate Date and Time HOWTO

- NTP Public Services Project

- Pachetul `ntp-doc`

| Indicație
`ntptrace`(8) din pachetul `ntp` poate urmări un lanț de servere NTP până la sursa primară.

### 9.5.6. Configurația terminalului

Există mai multe componente pentru configurarea consolei de caractere și a caracteristicilor sistemului `ncurses`(3).

- Fișierul „`/etc/terminfo/*/*`” (`terminfo`(5))

- Variabila de mediu „`$TERM`” (`term`(7))

- `setterm`(1), `stty`(1), `tic`(1), și `toe`(1)

Dacă intrarea `terminfo` pentru `xterm` nu funcționează cu un `xterm` non-Debian, schimbați tipul terminalului, „`$TERM`”, din „`xterm`” într-una dintre versiunile cu funcționalități limitate, cum ar fi „`xterm -r6`” atunci când vă conectați la un sistem Debian de la distanță. Consultați „`/usr/share/doc/libncurses5/FAQ`” pentru mai multe informații. „`dumb`” este cel mai mic numitor comun pentru „`$TERM`”.

### 9.5.7. Infrastructura de sunet

Controlorii pentru plăcile de sunet pentru versiunea actuală de Linux sunt furnizați de Advanced Linux Sound Architecture (ALSA). ALSA oferă modul de emulare pentru Open Sound System (OSS) anterior, pentru compatibilitate.

Aplicațiile software pot fi configurate nu numai pentru a accesa direct dispozitivele audio, ci și pentru a le accesa prin intermediul unui sistem standardizat de servere audio. În prezent, PulseAudio, JACK și PipeWire sunt utilizate ca sisteme de servere audio. Consultați Debian wiki page on Sound -- pagina wiki Debian despre sunet pentru a afla ultimele noutăți.

De obicei, există un motor de sunet comun pentru fiecare mediu grafic de birou popular. Fiecare motor de sunet utilizat de aplicație poate alege să se conecteze la diferite servere de sunet.

| Indicație
Utilizați „`cat /dev/urandom > /dev/audio`” sau `speaker-test`(1) pentru a testa difuzorul (^C pentru a opri).

| Indicație
Dacă nu auziți sunetul, este posibil ca difuzorul să fie conectat la o ieșire mută. Sistemele audio moderne au mai multe ieșiri. `alsamixer`(1) din pachetul `alsa-utils` este util pentru configurarea volumului și a opțiunilor de dezactivare a sunetului.

Tabel 9.15. Lista pachetelor de sunet

pachet | popcon(popularitate) | dimensiune | descriere
--- | --- | --- | ---
`alsa-utils` | V:341, I:475 | 2702 | Instrumente pentru configurarea și utilizarea ALSA
`oss-compat` | V:0, I:10 | 18 | compatibilitatea OSS sub ALSA previne erorile „`/dev/dsp not found`”
`pipewire` | V:316, I:373 | 142 | audio and video processing engine multimedia server - metapachet
`pipewire-bin` | V:324, I:373 | 2094 | audio and video processing engine multimedia server - server audio și programe CLI
`pipewire-alsa` | V:168, I:238 | 197 | audio and video processing engine multimedia server - server audio pentru a înlocui ALSA
`pipewire-pulse` | V:280, I:340 | 64 | audio and video processing engine multimedia server - server audio pentru a înlocui PulseAudio
`pulseaudio` | V:166, I:197 | 6606 | server PulseAudio
`libpulse0` | V:439, I:587 | 977 | bibliotecă client pentru PulseAudio
`jackd` | V:2, I:15 | 8 | server (latență redusă) JACK Audio Connection Kit. (JACK)
`libjack0` | V:2, I:9 | 330 | bibliotecă (latență redusă) pentru JACK Audio Connection Kit. (JACK)
`libgstreamer1.0-0` | V:465, I:602 | 5280 | GStreamer: motorul de sunet GNOME
`libphonon4qt5-4` | V:28, I:64 | 572 | Phonon: motorul de sunet KDE

### 9.5.8. Dezactivarea protectorului de ecran

Pentru a dezactiva protectorul de ecran, utilizați următoarele comenzi.

Tabel 9.16. Lista comenzilor pentru dezactivarea protectorului de ecran

mediu | comanda
--- | ---
Consola Linux | `setterm -powersave off`
Sistemul X Window (dezactivarea protectorului de ecran) | `xset s off`
Sistemul X Window (dezactivarea dpms) | `xset -dpms`
Sistemul X Window (intrerfața grafigă de configurare a protectorului de ecran) | `xscreensaver-command -prefs`

### 9.5.9. Dezactivarea bipurilor sonore

Se poate întotdeauna deconecta difuzorul PC-ului pentru a dezactiva sunetele bip. Eliminarea modulului nucleului `pcspkr` face acest lucru pentru dvs.

Următorul cod împiedică programul `readline`(3) utilizat de `bash`(1) să emită un semnal sonor atunci când întâlnește un caracter de alertă (ASCII=7).

    $ echo "set bell-style none">> ~/.inputrc

### 9.5.10. Utilizare memorie

Există 2 resurse disponibile pentru a afla situația utilizării memoriei.

- Mesajul de pornire al nucleului din „`/var/log/dmesg`” conține dimensiunea totală exactă a memoriei disponibile.

- `free`(1) și `top`(1) afișează informații despre resursele de memorie ale sistemului în funcțiune.

Iată un exemplu.

    # grep '\] Memory' /var/log/dmesg
    [    0.004000] Memory: 990528k/1016784k available (1975k kernel code, 25868k reserved, 931k data, 296k init)
    $ free -k
                 total       used       free     shared    buffers     cached
    Mem:        997184     976928      20256          0     129592     171932
    -/+ buffers/cache:     675404     321780
    Swap:      4545576          4    4545572

Poate vă întrebați „dmesg îmi arată că sunt disponibili 990 Mo, iar «free -k» arată că sunt disponibili 320 Mo. Lipsește mai mult de 600 Mo...”.

Nu vă faceți griji cu privire la dimensiunea mare a „`utilizată`” și dimensiunea mică a „`liberă`” din linia „`Mem:`”, ci citiți cea de sub ele (675404 și 321780 în exemplul de mai sus) și relaxați-vă.

Pentru MacBook-ul meu cu 1 Go = 1048576 k DRAM (sistemul video consumă o parte din această memorie), observ următoarele.

Tabel 9.17. Lista dimensiunilor memoriei raportate

raportare | dimensiune
--- | ---
Dimensiunea totală în dmesg | 1016784k = 1Go - 31792k
Liberă în dmesg | 990528k
Total sub shell | 997184k
Liberă sub shell | 20256k (dar efectiv 321780k)

### 9.5.11. Verificarea securității și integrității sistemului

O întreținere deficitară a sistemului poate expune sistemul la exploatare externă.

Pentru verificarea securității și integrității sistemului, ar trebui să începeți cu următoarele.

- Pachetul `debsums`, consultați `debsums`(1) și Secțiune 2.5.2, „Fișierul „Release” de nivel superior și autenticitatea”.

- Pachetul `chkrootkit`, consultați `chkrootkit`(1).

- Familia de pachete `clamav`, consultați `clamscan`(1) și `freshclam`(1).

- Debian security FAQ.

- Securing Debian Manual.

Tabel 9.18. Lista instrumentelor pentru verificarea securității și integrității sistemului

pachet | popcon(popularitate) | dimensiune | descriere
--- | --- | --- | ---
`logcheck` | V:5, I:6 | 120 | demon pentru a trimite prin poșta electronică anomaliile din fișierele jurnal ale sistemului către administrator
`debsums` | V:4, I:30 | 107 | ustensilă pentru verificarea fișierelor pachetelor instalate în raport cu sumele de control MD5
`chkrootkit` | V:9, I:14 | 966 | detector de rootkit
`clamav` | V:8, I:39 | 33154 | ustensilă antivirus pentru Unix - interfață de linie de comandă
`tiger` | V:1, I:1 | 7800 | raportează vulnerabilitățile de securitate ale sistemului
`tripwire` | V:1, I:1 | 5050 | verificator de integritate a fișierelor și directoarelor
`john` | V:1, I:7 | 469 | instrument activ de spargere a parolelor
`aide` | V:1, I:2 | 331 | mediu avansat de detectare a intruziunilor - binar static
`integrit` | V:0, I:0 | 2939 | program de verificare a integrității fișierelor
`crack` | V:0, I:0 | 153 | program de ghicire a parolelor

Iată un script simplu pentru a verifica permisiunile incorecte tipice ale fișierelor care pot fi scrise de oricine.

    # find / -perm 777 -a \! -type s -a \! -type l -a \! \( -type d -a -perm 1777 \)

| Atenție
Deoarece pachetul `debsums` utilizează sumele de control MD5 stocate local, acesta nu poate fi considerat pe deplin fiabil ca instrument de auditare a securității sistemului împotriva atacurilor rău intenționate.

## 9.6. Sfaturi pentru stocarea datelor

Booting your system as the Linux live system (see Secțiune 3.2.2, „Linux live rescue system on USB” and Secțiune 3.2.3, „Linux live rescue system from GRUB”) makes it easy for you to reconfigure data storage on the installed system.

Este posibil să fie necesar să demontați cu `umount`(8) unele dispozitive manual din linia de comandă înainte de a le utiliza, dacă acestea sunt montate automat de sistemul grafic de birou.

### 9.6.1. Utilizarea spațiului pe disc

Utilizarea spațiului pe disc poate fi evaluată cu ajutorul programelor furnizate de pachetele `mount`, `coreutils` și `xdu`:

- `mount`(8) raportează toate sistemele de fișiere montate (= discuri).

- `df`(1) raportează utilizarea spațiului pe disc pentru sistemul de fișiere.

- `du`(1) raportează utilizarea spațiului pe disc pentru arborele de directoare.

| Indicație
Puteți introduce rezultatul comenzii `du`(8) în `xdu`(1x) pentru a obține o prezentare grafică și interactivă cu „`du -k . |xdu`”, „`sudo du -k -x / |xdu`” etc.

### 9.6.2. Configurarea partițiilor de disc

Pentru configurarea partiției discului, deși `fdisk`(8) a fost considerat standard, `parted`(8) merită o anumită atenție. „Date de partiționare a discului”, „tabel de partiții”, „hartă de partiții” și „etichetă de disc” sunt toate sinonime.

PC-urile mai vechi utilizează schema clasică Master Boot Record (MBR) pentru a stoca datele de partiționare a discului în primul sector, adică sectorul 0 LBA (512 octeți).

PC-urile recente cu Unified Extensible Firmware Interface (UEFI), inclusiv Mac-urile bazate pe Intel, utilizează schema GUID Partition Table (GPT) pentru a stoca datele de partiționare a discului care nu se află în primul sector.

Deși `fdisk`(8) a fost standardul pentru instrumentul de partiționare a discurilor, `parted`(8) îl înlocuiește.

Tabel 9.19. Lista pachetelor de gestionare a partițiilor de disc

pachet | popcon(popularitate) | dimensiune | descriere
--- | --- | --- | ---
`util-linux` | V:897, I:999 | 4384 | utilitare de sistem diverse, inclusiv `fdisk`(8) și `cfdisk`(8)
`parted` | V:445, I:579 | 126 | programul GNU Parted pentru redimensionarea partițiilor de disc
`gparted` | V:13, I:92 | 2313 | editor de partiții GNOME bazat pe `libparted`
`gdisk` | V:20, I:309 | 940 | editor de partiții pentru discul hibrid GPT/MBR
`kpartx` | V:17, I:27 | 78 | program pentru crearea hărților dispozitivelor pentru partiții

| Atenție
Deși `parted`(8) pretinde că creează și redimensionează sistemul de fișiere, este mai sigur să faceți astfel de lucruri folosind instrumente specializate bine întreținute, cum ar fi `mkfs` (8) (`mkfs.msdos`(8), `mkfs.ext2`(8), `mkfs.ext3`(8), `mkfs.ext4`(8), …) și `resize2fs`(8).

| Notă
Pentru a comuta între GPT și MBR, trebuie să ștergeți direct primele câteva blocuri din conținutul discului (consultați Secțiune 9.8.6, „Ștergerea conținutului fișierului”) și să utilizați „`parted /dev/sdx mklabel gpt`” sau „`parted /dev/sdx mklabel msdos`” pentru a-l pune în loc. Rețineți că „`msdos`” este utilizat aici pentru MBR.

### 9.6.3. Accesarea partiției folosind UUID

Deși reconfigurarea partiției sau ordinea de activare a mediilor de stocare amovibile poate genera denumiri diferite pentru partiții, puteți accesa aceste partiții în mod consecvent. Acest lucru este util și în cazul în care aveți mai multe discuri, iar BIOS/UEFI nu le atribuie denumiri consecvente.

- `mount`(8) cu opțiunea „`-U`” poate monta un dispozitiv de blocuri folosind UUID, în loc să folosească numele fișierului, cum ar fi „`/dev/sda3`”.

- „`/etc/fstab`” (a se vedea `fstab`(5)) poate utiliza UUID.

- Încărcătoarele de pornire (Secțiune 3.1.2, „Etapa 2: încărcătorul de pornire”) pot utiliza de asemenea UUID.

| Indicație
Puteți verifica UUID-ul unui dispozitiv special de blocuri cu `blkid`(8). De asemenea, puteți verifica UUID-ul și alte informații cu „`lsblk -f`”.

### 9.6.4. LVM2

LVM2 este un manager de volume logice pentru nucleul Linux. Cu LVM2, partițiile de disc pot fi create pe volume logice în loc de discuri dure fizice.

LVM necesită următoarele.

- suport pentru «device-mapper» în nucleul Linux (implicit pentru nucleele Debian)

- biblioteca de suport pentru cartografierea dispozitivelor în spațiul utilizatorului (pachetul `libdevmapper*`)

- instrumentele LVM2 din spațiul utilizatorului (pachetul `lvm2`)

Vă rugăm să începeți să învățați LVM2 din următoarele pagini de manual.

- `lvm`(8): noțiuni de bază despre mecanismul LVM2 (lista tuturor comenzilor LVM2)

- `lvm.conf`(5): fișierul de configurare pentru LVM2

- `lvs`(8): raportează informații despre volumele logice

- `vgs`(8): raportează informații despre grupurile de volume

- `pvs`(8): raportează informații despre volumele fizice

### 9.6.5. Configurarea sistemului de fișiere

Pentru sistemul de fișiere ext4, pachetul `e2fsprogs` oferă următoarele.

- `mkfs.ext4`(8) pentru a crea un nou sistem de fișiere ext4

- `fsck.ext4`(8) pentru a verifica și repara sistemul de fișiere ext4 existent

- `tune2fs`(8) pentru a configura superblocul sistemului de fișiere ext4

- `debugfs`(8) pentru a depana interactiv sistemul de fișiere ext4; acesta are comanda `undel` pentru a recupera fișierele șterse).

Comenzile `mkfs`(8) și `fsck`(8) sunt furnizate de pachetul `e2fsprogs` ca interfețe pentru diverse programe dependente de sistemul de fișiere (`mkfs.fstype` și `fsck.fstype`). Pentru sistemul de fișiere ext4, acestea sunt `mkfs.ext4`(8) și `fsck.ext4`(8) (acestea sunt legate simbolic de `mke2fs`(8) și `e2fsck`(8)).

Comenzi similare sunt disponibile pentru fiecare sistem de fișiere acceptat de Linux.

Tabel 9.20. Lista pachetelor de gestionare a sistemului de fișiere

pachet | popcon(popularitate) | dimensiune | descriere
--- | --- | --- | ---
`e2fsprogs` | V:796, I:997 | 1549 | ustensie pentru sistemele de fișiere ext2/ext3/ext4
`btrfs-progs` | V:48, I:76 | 5204 | ustensile pentru sistemul de fișiere Btrfs
`reiserfsprogs` | V:9, I:21 | 473 | ustensile pentru sistemul de fișiere Reiserfs
`zfsutils-linux` | V:31, I:32 | 1891 | ustensile pentru sistemul de fișiere OpenZFS
`dosfstools` | V:247, I:572 | 310 | ustensile pentru sistemul de fișiere FAT (Microsoft: MS-DOS, Windows)
`exfatprogs` | V:36, I:467 | 352 | ustensile pentru sistemul de fișiere exFAT menținut de Samsung.
`exfat-fuse` | V:2, I:50 | 73 | citește/scrie sistemul de fișiere exFAT controlor (Microsoft) pentru FUSE.
`xfsprogs` | V:36, I:86 | 4386 | ustensile pentru sistemul de fișiere XFS (SGI: IRIX)
`ntfs-3g` | V:193, I:527 | 1500 | citește/scrie sistemul de fișiere NTFS (Microsoft: Windows NT, …) controlor pentru FUSE.
`jfsutils` | V:0, I:7 | 1104 | ustensile pentru sistemul de fișiere JFS. (IBM: AIX, OS/2)
`xorriso` | V:14, I:63 | 347 | utilities for the ISO-9660 filesystem and CD/DVD writing from libburnia
`wodim` | V:8, I:96 | 898 | command line CD/DVD writing tool from cdrkit
`genisoimage` | V:18, I:167 | 1567 | command line ISO-9660 filesystem tool from cdrkit
`reiser4progs` | V:0, I:1 | 1367 | ustensile pentru sistemul de fișiere Reiser4
`hfsprogs` | V:0, I:3 | 394 | ustensile pentru sistemul de fișiere HFS și HFS Plus (Apple: Mac OS)
`zerofree` | V:5, I:119 | 30 | program pentru a șterge blocurile libere din sistemele de fișiere ext2/3/4

| Indicație

Sistemul de fișiere Ext4 este sistemul de fișiere implicit pentru sistemul Linux și se recomandă insistent utilizarea acestuia, cu excepția cazului în care aveți motive specifice pentru a nu o face.

Starea Btrfs poate fi găsită la Debian wiki on btrfs și kernel.org wiki on btrfs. Se preconizează că acesta va fi următorul sistem de fișiere implicit după sistemul de fișiere ext4.

Unele instrumente permit accesul la sistemul de fișiere fără suportulasigurat de nucleul Linux (a se vedea Secțiune 9.8.2, „Manipularea fișierelor fără montarea discului”).

### 9.6.6. Crearea sistemului de fișiere și verificarea integrității

Comanda `mkfs`(8) creează sistemul de fișiere într-un sistem Linux. Comanda `fsck`(8) asigură verificarea integrității și repararea sistemului de fișiere într-un sistem Linux.

Debian nu mai execută implicit comanda `fsck` după crearea sistemului de fișiere.

| Atenție
În general, nu este sigur să rulați `fsck` pe sisteme de fișiere montate.

| Indicație

Puteți rula comanda `fsck`(8) în siguranță pe toate sistemele de fișiere, inclusiv pe sistemul de fișiere rădăcină la repornire, definind „`enable_periodic_fsck`” în „`/etc/mke2fs.conf`” și numărul maxim de montări la 0 folosind „`tune2fs -c0 /dev/partition_name`”. Consultați `mke2fs.conf`(5) și `tune2fs`(8).

Verificați fișierele din „`/var/log/fsck/`” pentru rezultatul comenzii `fsck`(8) executată din scriptul de pornire.

### 9.6.7. Optimizarea sistemului de fișiere prin opțiuni de montare

Configurația statică de bază a sistemului de fișiere este dată de „`/etc/fstab`”. De exemplu,

    «file system»                   «mount point» «type» «options»    «dump» «pass»
    proc                                      /proc proc   defaults          0 0
    UUID=709cbe4c-80c1-56db-8ab1-dbce3146d2f7 /     ext4   errors=remount-ro 0 1
    UUID=817bae6b-45d2-5aca-4d2a-1267ab46ac23 none  swap   sw                0 0
    /dev/scd0                        /media/cdrom0  udf,iso9660 user,noauto  0 0

| Indicație
UUID (vedeți Secțiune 9.6.3, „Accesarea partiției folosind UUID”) poate fi utilizat pentru a identifica un dispozitiv de blocuri în locul numelor normale ale dispozitivelor de bloc, cum ar fi „`/dev/sda1`”, „`/dev/sda2`”, …

Începând cu Linux 2.6.30, nucleul utilizează în mod implicit comportamentul oferit de opțiunea „`relatime`”.

Consultați `fstab`(5) și `mount`(8).

### 9.6.8. Optimizarea sistemului de fișiere prin super-bloc

Caracteristicile unui sistem de fișiere pot fi optimizate prin intermediul super-blocului său, utilizând comanda `tune2fs`(8).

- Executarea comenzii „`sudo tune2fs -l /dev/sda1`” afișează conținutul super-blocului sistemului de fișiere pe „`/dev/sda1`”.

- Executarea comenzii „`sudo tune2fs -c 50 /dev/sda1`” modifică frecvența verificărilor sistemului de fișiere (executarea comenzii „`fsck`” în timpul pornirii) la fiecare 50 de porniri pe „`/dev/sda1`”.

- Executarea comenzii „`sudo tune2fs -j /dev/sda1`” adaugă capacitatea de jurnalizare la sistemul de fișiere, adică conversia sistemului de fișiere de la ext2 la ext3 pe „`/dev/sda1`”; (efectuați această operațiune pe sistemul de fișiere nemontat).

- Executarea comenzii „`sudo tune2fs -O extents,uninit_bg,dir_index /dev/sda1 && fsck -pf /dev/sda1`” convertește partiția din ext3 în ext4 pe „`/dev/sda1`”; (faceți acest lucru pe sistemul de fișiere nemontat).

| Indicație
În ciuda numelui său, `tune2fs`(8) funcționează nu numai pe sistemul de fișiere ext2, ci și pe sistemele de fișiere ext3 și ext4.

### 9.6.9. Optimizarea discului dur

| Avertisment
Vă rugăm să verificați hardware-ul și să citiți pagina de manual a `hdparm`(8) înainte de a modifica configurația discului dur, deoarece acest lucru poate fi destul de periculos pentru integritatea datelor.

Puteți testa viteza de acces a unui disc dur, de exemplu „`/dev/sda`”, cu „`hdparm -tT /dev/sda`”. Pentru unele discuri dure conectate cu (E)IDE, puteți accelera viteza cu „`hdparm -q -c3 -d1 -u1 -m16 /dev/sda`” activând „(E) IDE 32-bit I/O support”, activând „fanionul using_dma”, activând „fanionul interrupt-unmask” și definind „multiple 16 sector I/O” (periculos!).

Puteți testa funcția de memorie cache de scriere a unui disc dur, de exemplu „`/dev/sda`”, cu „`hdparm -W /dev/sda`”. Puteți dezactiva funcția de memorie cache de scriere cu „`hdparm -W 0 /dev/sda`”.

Este posibil să puteți citi CD-ROM-urile preconfigurate defectuos pe unitățile CD-ROM moderne de mare viteză, încetinind-o cu „`setcd -x 2`”.

### 9.6.10. Optimizarea discului cu stare solidă

Discul/unitatea cu stare solidă („Solid State Drive”: SSD) este detectată automat acum.

Reduceți accesările inutile la disc pentru a preveni uzura discului prin montarea „`tmpfs`” în ruta de date volatile din `/etc/fstab`.

### 9.6.11. Utilizarea SMART pentru a prezice defectarea discului dur

Puteți monitoriza și înregistra discul dvs. dur compatibil cu SMART cu ajutorul demonului `smartd`(8).

1. Activați funcția SMART în BIOS.

2. Instalați pachetul `smartmontools`.

3. Identificați unitățile de disc dur listându-le cu `df`(1).

   - Să presupunem că unitatea de disc dur care trebuie monitorizată este „`/dev/sda`”.

4. Verificați rezultatul comenzii „`smartctl -a /dev/sda`” pentru a vedea dacă funcția SMART este activată.

   - Dacă nu, activați-o cu „`smartctl -s on -a /dev/sda`”.

5. Activați demonul `smartd`(8) pentru a rula astfel.

   - decomentați „`start_smartd=yes`” din fișierul „`/etc/default/smartmontools`”.

   - reporniți demonul `smartd`(8) cu comanda „`sudo systemctl restart smartmontools`”.

| Indicație
Demonul `smartd`(8) poate fi personalizat cu ajutorul fișierului `/etc/smartd.conf`, inclusiv modul în care se pot primi notificări de avertizare.

### 9.6.12. Specificați directorul de stocare temporară prin $TMPDIR

Aplicațiile creează fișiere temporare în mod normal în directorul de stocare temporară „`/tmp`”. Dacă „`/tmp`” nu oferă suficient spațiu, puteți specifica un astfel de director de stocare temporară prin variabila `$TMPDIR` pentru programele care o acceptă.

### 9.6.13. Extinderea spațiului de stocare utilizabil prin LVM

Partițiile create cu ajutorul Managerul de volume logice („Logical Volume Manager”: LVM) (funcționalitate Linux) în momentul instalării pot fi redimensionate cu ușurință prin concatenarea extinderilor pe acestea sau prin trunchierea extinderilor de pe acestea pe mai multe dispozitive de stocare, fără a fi necesară o reconfigurare majoră a sistemului.

### 9.6.14. Extinderea spațiului de stocare utilizabil prin montarea unei alte partiții

Dacă aveți o partiție goală (de exemplu, „`/dev/sdx`”), o puteți formata cu `mkfs.ext4`(1) și o puteți monta `mount` (8) într-un director în care aveți nevoie de mai mult spațiu; (trebuie să copiați conținutul original al datelor).

    $ sudo mv work-dir old-dir
    $ sudo mkfs.ext4 /dev/sdx
    $ sudo mount -t ext4 /dev/sdx work-dir
    $ sudo cp -a old-dir/* work-dir
    $ sudo rm -rf old-dir

| Indicație
Alternativ, puteți monta un fișier imagine disc gol (consultați Secțiune 9.7.5, „Crearea fișierului imagine de disc gol”) ca dispozitiv loop (consultați Secțiune 9.7.3, „Montarea fișierului imagine disc”). Utilizarea efectivă a discului crește odată cu datele efectiv stocate.

### 9.6.15. Extinderea spațiului de stocare utilizabil prin montarea unui alt director

Dacă aveți un director gol (de exemplu, „`/path/to/emp-dir`”) pe o altă partiție cu spațiu utilizabil, îl puteți monta (8) cu opțiunea „`--bind`” într-un director (de exemplu, „`work-dir`”) unde aveți nevoie de mai mult spațiu.

    $ sudo mount --bind /path/to/emp-dir work-dir

### 9.6.16. Extinderea spațiului de stocare utilizabil prin montarea suprapusă a unui alt director

Dacă aveți spațiu utilizabil într-o altă partiție (de exemplu, „`/path/to/empty`” și „`/path/to/work`”), puteți crea un director în aceasta și îl puteți stivui pe un director vechi (de exemplu, „`/path/to/old` ”) unde aveți nevoie de spațiu, utilizând OverlayFS pentru nucleul Linux 3.18 sau mai recent (Debian Stretch 9.0 sau mai recent).

    $ sudo mount -t overlay overlay \
      -olowerdir=/path/to/old-dir,upperdir=/path/to/empty,workdir=/path/to/work

Aici, „`/path/to/empty`” și „`/path/to/work`” ar trebui să se afle pe partiția cu acces RW pentru a scrie pe „`/path/to/old`”.

### 9.6.17. Extinderea spațiului de stocare utilizabil folosind legături simbolice

| Atenție
Aceasta este o metodă învechită. Unele programe software pot să nu funcționeze bine cu o „legătură simbolică către un director”. În schimb, utilizați metodele de „montare” descrise mai sus.

Dacă aveți un director gol (de exemplu, „`/path/to/emp-dir`”) într-o altă partiție cu spațiu utilizabil, puteți crea o legătură simbolică către director cu `ln`(8).

    $ sudo mv work-dir old-dir
    $ sudo mkdir -p /path/to/emp-dir
    $ sudo ln -sf /path/to/emp-dir work-dir
    $ sudo cp -a old-dir/* work-dir
    $ sudo rm -rf old-dir

| Avertisment
Nu utilizați o „legătură simbolică către un director” pentru directoarele gestionate de sistem, cum ar fi „`/opt`”. O astfel de legătură simbolică poate fi suprascrisă atunci când sistemul este actualizat.

## 9.7. Imaginea discului

Aici discutăm despre manipulările imaginii discului.

### 9.7.1. Crearea fișierului imagine de disc

The disk image file, "`disk.img`", of an unmounted device, e.g., the second SCSI or serial ATA drive "`/dev/sdb`", can be made by one of the following.

    # dd if=/dev/sdb of=disk.img; sync

    # cp /dev/sdb disk.img ; sync

    # cat /dev/sdb > disk.img ; sync

Imaginea discului master boot record (MBR) (a se vedea Secțiune 9.6.2, „Configurarea partițiilor de disc”) al unui PC tradițional, care se află în primul sector al discului IDE primar, poate fi creată folosind `dd`(1) după cum urmează.

    # dd if=/dev/sda of=mbr.img bs=512 count=1
    # dd if=/dev/sda of=mbr-nopart.img bs=446 count=1
    # dd if=/dev/sda of=mbr-part.img skip=446 bs=1 count=66

- "`mbr.img`": MBR-ul cu tabelul de partiții

- "`mbr-nopart.img`": MBR-ul fără tabelul de partiții

- "`mbr-part.img`": Doar tabelul de partiții al MBR

Dacă creați o imagine a unei partiții a discului original, înlocuiți „`/dev/sda`” cu „`/dev/sda1`” etc.

### 9.7.2. Scrierea direct pe disc

The disk image file, "`disk.img`" can be written to an unmounted device, e.g., the second SCSI drive "`/dev/sdb`" with matching size, by one of the following.

    # dd if=disk.img of=/dev/sdb ; sync

    # cp disk.img /dev/sdb ; sync

    # cat disk.img >/dev/sdb ; sync

În mod similar, fișierul imagine al partiției de disc, „`partition.img`”, poate fi scris pe o partiție nemontată, de exemplu, prima partiție a celui de-al doilea disc SCSI „`/dev/sdb1`” cu dimensiunea corespunzătoare, prin următoarea comandă.

    # dd if=partition.img of=/dev/sdb1 ; sync

### 9.7.3. Montarea fișierului imagine disc

Imaginea de disc „`partition.img`” care conține o singură imagine de partiție poate fi montată și demontată utilizând dispozitivul de buclă loop device după cum urmează.

    # losetup --show -f partition.img
    /dev/loop0
    # mkdir -p /mnt/loop0
    # mount -t auto /dev/loop0 /mnt/loop0
    ...hack...hack...hack
    # umount /dev/loop0
    # losetup -d /dev/loop0

Acest lucru poate fi simplificat după cum urmează.

    # mkdir -p /mnt/loop0
    # mount -t auto -o loop partition.img /mnt/loop0
    ...hack...hack...hack
    # umount partition.img

Fiecare partiție a imaginii discului „`disk.img`” care conține mai multe partiții poate fi montată utilizând dispozitivul de buclă loop device.

    # losetup --show -f -P disk.img
    /dev/loop0
    # ls -l /dev/loop0*
    brw-rw---- 1 root disk   7,  0 Apr  2 22:51 /dev/loop0
    brw-rw---- 1 root disk 259, 12 Apr  2 22:51 /dev/loop0p1
    brw-rw---- 1 root disk 259, 13 Apr  2 22:51 /dev/loop0p14
    brw-rw---- 1 root disk 259, 14 Apr  2 22:51 /dev/loop0p15
    # fdisk -l /dev/loop0
    Disk /dev/loop0: 2 GiB, 2147483648 bytes, 4194304 sectors
    Units: sectors of 1 * 512 = 512 bytes
    Sector size (logical/physical): 512 bytes / 512 bytes
    I/O size (minimum/optimal): 512 bytes / 512 bytes
    Disklabel type: gpt
    Disk identifier: 6A1D9E28-C48C-2144-91F7-968B3CBC9BD1

    Device         Start     End Sectors  Size Type
    /dev/loop0p1  262144 4192255 3930112  1.9G Linux root (x86-64)
    /dev/loop0p14   2048    8191    6144    3M BIOS boot
    /dev/loop0p15   8192  262143  253952  124M EFI System

    Partition table entries are not in disk order.
    # mkdir -p /mnt/loop0p1
    # mkdir -p /mnt/loop0p15
    # mount -t auto /dev/loop0p1 /mnt/loop0p1
    # mount -t auto /dev/loop0p15 /mnt/loop0p15
    # mount |grep loop
    /dev/loop0p1 on /mnt/loop0p1 type ext4 (rw,relatime)
    /dev/loop0p15 on /mnt/loop0p15 type vfat (rw,relatime,fmask=0002,dmask=0002,allow_utime=0020,codepage=437,iocharset=ascii,shortname=mixed,utf8,errors=remount-ro)
    ...hack...hack...hack
    # umount /dev/loop0p1
    # umount /dev/loop0p15
    # losetup -d /dev/loop0

Alternativ, efecte similare pot fi obținute utilizând dispozitivele device mapper create de `kpartx`(8) din pachetul `kpartx`, după cum urmează.

    # kpartx -a -v disk.img
    add map loop0p1 (253:0): 0 3930112 linear 7:0 262144
    add map loop0p14 (253:1): 0 6144 linear 7:0 2048
    add map loop0p15 (253:2): 0 253952 linear 7:0 8192
    # fdisk -l /dev/loop0
    Disk /dev/loop0: 2 GiB, 2147483648 bytes, 4194304 sectors
    Units: sectors of 1 * 512 = 512 bytes
    Sector size (logical/physical): 512 bytes / 512 bytes
    I/O size (minimum/optimal): 512 bytes / 512 bytes
    Disklabel type: gpt
    Disk identifier: 6A1D9E28-C48C-2144-91F7-968B3CBC9BD1

    Device         Start     End Sectors  Size Type
    /dev/loop0p1  262144 4192255 3930112  1.9G Linux root (x86-64)
    /dev/loop0p14   2048    8191    6144    3M BIOS boot
    /dev/loop0p15   8192  262143  253952  124M EFI System

    Partition table entries are not in disk order.
    # ls -l /dev/mapper/
    total 0
    crw------- 1 root root 10, 236 Apr  2 22:45 control
    lrwxrwxrwx 1 root root       7 Apr  2 23:19 loop0p1 -> ../dm-0
    lrwxrwxrwx 1 root root       7 Apr  2 23:19 loop0p14 -> ../dm-1
    lrwxrwxrwx 1 root root       7 Apr  2 23:19 loop0p15 -> ../dm-2
    # mkdir -p /mnt/loop0p1
    # mkdir -p /mnt/loop0p15
    # mount -t auto /dev/mapper/loop0p1 /mnt/loop0p1
    # mount -t auto /dev/mapper/loop0p15 /mnt/loop0p15
    # mount |grep loop
    /dev/loop0p1 on /mnt/loop0p1 type ext4 (rw,relatime)
    /dev/loop0p15 on /mnt/loop0p15 type vfat (rw,relatime,fmask=0002,dmask=0002,allow_utime=0020,codepage=437,iocharset=ascii,shortname=mixed,utf8,errors=remount-ro)
    ...hack...hack...hack
    # umount /dev/mapper/loop0p1
    # umount /dev/mapper/loop0p15
    # kpartx -d disk.img

### 9.7.4. Curățarea unui fișier imagine de disc

Un fișier imagine de disc, „`disk.img`”, poate fi curățat de toate fișierele eliminate într-o imagine curată și de dimensiune mai redusă „`new.img`” prin următoarele.

    # mkdir old; mkdir new
    # mount -t auto -o loop disk.img old
    # dd bs=1 count=0 if=/dev/zero of=new.img seek=5G
    # mount -t auto -o loop new.img new
    # cd old
    # cp -a --sparse=always ./ ../new/
    # cd ..
    # umount new.img
    # umount disk.img

Dacă „`disk.img`” este în ext2, ext3 sau ext4, puteți utiliza și `zerofree`(8) din pachetul `zerofree` după cum urmează.

    # losetup --show -f disk.img
    /dev/loop0
    # zerofree /dev/loop0
    # cp --sparse=always disk.img new.img
    # losetup -d /dev/loop0

### 9.7.5. Crearea fișierului imagine de disc gol

Imaginea de disc goală „`disk.img`”, care poate crește până la 5 Gio, poate fi creată folosind `dd`(1) după cum urmează.

    $ dd bs=1 count=0 if=/dev/zero of=disk.img seek=5G

În loc să se utilizeze `dd`(1), aici se poate utiliza `fallocate`(8) specializat.

Puteți crea un sistem de fișiere ext4 pe această imagine de disc „`disk.img`” utilizând dispozitivul de buclă loop device după cum urmează.

    # losetup --show -f disk.img
    /dev/loop0
    # mkfs.ext4 /dev/loop0
    ...hack...hack...hack
    # losetup -d /dev/loop0
    $ du  --apparent-size -h disk.img
    5.0G  disk.img
    $ du -h disk.img
    83M disk.img

Pentru „`disk.img`”, dimensiunea fișierului este de 5,0 Gio, iar utilizarea efectivă a discului este de doar 83 Mio. Această discrepanță este posibilă deoarece ext4 poate stoca fișiere disperse.

| Indicație
Utilizarea efectivă a discului de către fișierul dispers crește odată cu datele care sunt scrise pe acesta.

Folosind o operație similară pe dispozitivele create de dispozitivul de buclă loop device sau device mapper ca în Secțiune 9.7.3, „Montarea fișierului imagine disc”, puteți partiționa această imagine de disc „`disk.img`” folosind `parted`(8) sau `fdisk`(8) și puteți crea un sistem de fișiere pe acesta folosind `mkfs.ext4`(8), `mkswap`(8) etc.

### 9.7.6. Crearea fișierului imagine ISO9660

| Indicație
Both `genisoimage`(1) provided by cdrkit and `xorrisofs`(1) provided by Libburnia share the same command syntax except for the command name.

Fișierul imagine ISO9660 „`cd.iso`” din arborele directorului sursă „`source_directory`” poate fi creată folosind `genisoimage`(1) furnizat de cdrkit după cum urmează.

    #  genisoimage -r -J -T -V volume_id -o cd.iso source_directory

În mod similar, fișierul imagine ISO9660 ce poate fi pornit, „`cdboot.iso`”, poate fi creat din `debian-installer`, ca arbore de directoare în „`source_directory`”, prin următoarele.

    #  genisoimage -r -o cdboot.iso -V volume_id \
       -b isolinux/isolinux.bin -c isolinux/boot.cat \
       -no-emul-boot -boot-load-size 4 -boot-info-table source_directory

Aici încărcătorul de pornire Isolinux Isolinux boot loader (a se vedea Secțiune 3.1.2, „Etapa 2: încărcătorul de pornire”) este utilizat pentru pornire.

Puteți calcula valoarea md5sum și crea imaginea ISO9660 direct de pe dispozitivul CD-ROM, după cum urmează.

    $ isoinfo -d -i /dev/cdrom
    CD-ROM is in ISO 9660 format
    ...
    Logical block size is: 2048
    Volume size is: 23150592
    ...
    # dd if=/dev/cdrom bs=2048 count=23150592 conv=notrunc,noerror | md5sum
    # dd if=/dev/cdrom bs=2048 count=23150592 conv=notrunc,noerror > cd.iso

| Avertisment
Pentru a obține rezultatul corect, trebuie să evitați cu atenție eroarea de citire anticipată a sistemului de fișiere ISO9660 din Linux, așa cum este descris mai sus.

### 9.7.7. Scrierea în mod direct pe CD/DVD-R/RW

| Indicație
DVD is only a large CD to `wodim`(1) provided by cdrkit and `xorrecord`(1) provided by Libburnia. These commands share the same command syntax except for the command name.

Puteți găsi un dispozitiv utilizabil după cum urmează.

    # wodim --devices

Apoi, CD-ul gol este introdus în unitatea CD, iar fișierul imagine ISO9660, „`cd.iso`”, este scris pe acest dispozitiv, de exemplu „`/dev/sda`”, folosind `wodim`(1) după cum urmează.

    # wodim -v -eject dev=/dev/sda cd.iso

Dacă se utilizează CD-RW în loc de CD-R, procedați în felul următor.

    # wodim -v -eject blank=fast dev=/dev/sda cd.iso

| Indicație
Dacă sistemul dvs. de birou montează automat CD-urile, demontați-l cu comanda „`sudo umount /dev/sda`” din consolă înainte de a utiliza `wodim`(1).

### 9.7.8. Montarea fișierului imagine ISO9660

Dacă „`cd.iso`” conține o imagine ISO9660, atunci următoarea comandă o montează manual în „`/cdrom`”.

    # mount -t iso9660 -o ro,loop cd.iso /cdrom

| Indicație
Sistemele grafice de birou moderne pot monta automat suporturi amovibile, cum ar fi CD-urile formatate ISO9660 (vedeți Secțiune 10.1.7, „Removable storage device”).

## 9.8. Datele binare

Aici discutăm despre manipularea directă a datelor binare pe suporturile de stocare.

### 9.8.1. Vizualizarea și editarea datelor binare

Cea mai simplă metodă de vizualizare a datelor binare este utilizarea comenzii „`od -t x1`”.

Tabel 9.21. Lista pachetelor care vizualizează și editează date binare

pachet | popcon(popularitate) | dimensiune | descriere
--- | --- | --- | ---
`coreutils` | V:892, I:999 | 18457 | pachetul de bază care are `od`(1) pentru a descărca fișiere (HEX, ASCII, OCTAL, …)
`bsdmainutils` | V:4, I:152 | 17 | pachet de ustensiler care are `hd`(1) pentru a descărca fișiere (HEX, ASCII, OCTAL, …)
`hexedit` | V:1, I:8 | 70 | editor și vizor binar (HEX, ASCII)
`bless` | V:0, I:1 | 924 | editor hexazecimal cu funcții avansate (GNOME)
`okteta` | V:1, I:12 | 1590 | editor hexazecimal cu funcții avansate (KDE4)
`ncurses-hexedit` | V:0, I:1 | 130 | editor și vizor binar (HEX, ASCII, EBCDIC)
`beav` | V:0, I:0 | 137 | editor și vizor binar (HEX, ASCII, EBCDIC, OCTAL, …)

| Indicație
HEX este utilizat ca acronim pentru formatul hexazecimal cu baza numerică 16. OCTAL este pentru formatul octal cu baza numerică 8. ASCII este pentru Codul standard american pentru schimbul de informații, adică codul normal al textului în limba engleză. EBCDIC este pentru Extended Binary Coded Decimal Interchange Code utilizat pe sistemele de operare IBM mainframe.

### 9.8.2. Manipularea fișierelor fără montarea discului

Există instrumente pentru citirea și scrierea fișierelor fără montarea discului.

Tabel 9.22. Lista pachetelor pentru manipularea fișierelor fără montarea discului

pachet | popcon(popularitate) | dimensiune | descriere
--- | --- | --- | ---
`mtools` | V:7, I:54 | 400 | instrumente pentru fișiere MSDOS fără a le monta
`hfsutils` | V:0, I:3 | 178 | instrumente pentru fișiere HFS și HFS+ fără a le monta

### 9.8.3. Redundanța datelor

Sistemele software RAID oferite de nucleul Linux asigură redundanța datelor la nivelul sistemului de fișiere al nucleului pentru a obține un nivel ridicat de fiabilitate a stocării.

Există instrumente pentru a adăuga redundanță de date la fișiere la nivel de program de aplicație, pentru a obține niveluri ridicate de fiabilitate a stocării.

Tabel 9.23. Lista instrumentelor pentru adăugarea redundanței datelor la fișiere

pachet | popcon(popularitate) | dimensiune | descriere
--- | --- | --- | ---
`par2` | V:10, I:119 | 298 | set de volume de arhivă Parity (Parity Archive Volume Set), pentru verificarea și repararea fișierelor
`dvdisaster` | V:0, I:1 | 1422 | protecție împotriva pierderii datelor/zgârieturilor/îmbătrânirii pentru suporturile CD/DVD
`dvbackup` | V:0, I:0 | 413 | instrument de copie de rezervă utilizând camere video MiniDV (furnizând `rsbep`(1))

### 9.8.4. Recuperarea fișierelor de date și analiza tehnico-criminalistică

Există instrumente pentru recuperarea fișierelor de date și analiza tehnico-criminalistică.

Tabel 9.24. Lista pachetelor pentru recuperarea fișierelor de date și analiza tehnico-criminalistică

pachet | popcon(popularitate) | dimensiune | descriere
--- | --- | --- | ---
`testdisk` | V:2, I:26 | 1495 | ustensile pentru scanarea partițiilor și recuperarea discurilor
`magicrescue` | V:0, I:2 | 257 | ustensilă pentru recuperarea fișierelor prin căutarea de octeți magici
`scalpel` | V:0, I:2 | 89 | economic, cu performanțe ridicate în prelucrarea fișierelor pentru recuperarea acestora
`myrescue` | V:0, I:2 | 83 | recuperează date de pe discuri dure deteriorate
`extundelete` | V:0, I:7 | 152 | instrument pentru recuperarea fișierelor șterse din sistemul de fișiere ext3/4
`ext4magic` | V:0, I:3 | 235 | instrument pentru recuperarea fișierelor șterse din sistemul de fișiere ext3/4
`ext3grep` | V:0, I:2 | 299 | instrument pentru recuperarea fișierelor șterse din sistemul de fișiere ext3
`scrounge-ntfs` | V:0, I:1 | 49 | program de recuperare a datelor pentru sisteme de fișiere NTFS
`gzrt` | V:0, I:0 | 33 | set de instrumente de recuperare gzip
`sleuthkit` | V:2, I:23 | 1729 | instrumente pentru analiza tehnico-criminalistică. (Sleuthkit -- Kit de detectiv)
`autopsy` | V:0, I:1 | 1026 | interfață grafică pentru SleuthKit
`foremost` | V:0, I:4 | 102 | aplicație tehnico-criminalistică pentru recuperarea datelor
`guymager` | V:0, I:0 | 1047 | instrument de procesare a imaginilor de fișiere tehnico-criminalistică bazat pe Qt
`dcfldd` | V:0, I:2 | 113 | versiune îmbunătățită a `dd` pentru analiză tehnico-criminalistică și securitate

| Indicație
Puteți recupera fișierele șterse din sistemul de fișiere ext2 folosind comenzile `list_deleted_inodes` și `undel` din `debugfs`(8) din pachetul `e2fsprogs`.

### 9.8.5. Împărțirea unui fișier mare în fișiere mici

Când un fișier este prea mare pentru a fi copiat ca un singur fișier, puteți copia conținutul acestuia după ce îl împărțiți în bucăți de, de exemplu, 2000 Mio și apoi puteți reuni aceste bucăți în fișierul original.

    $ split -b 2000m large_file
    $ cat x* >large_file

| Atenție
Asigurați-vă că nu aveți fișiere care încep cu „`x`” pentru a evita conflictele de nume.

### 9.8.6. Ștergerea conținutului fișierului

Pentru a șterge conținutul unui fișier, cum ar fi un fișier jurnal, nu utilizați `rm`(1) pentru a șterge fișierul și apoi creați un fișier gol nou, deoarece fișierul poate fi accesat în intervalul dintre comenzi. Următoarea este metoda sigură de a șterge conținutul fișierului.

    $ :>file_to_be_cleared

### 9.8.7. Fișiere fictive

Următoarele comenzi creează fișiere fictive sau goale.

    $ dd if=/dev/zero    of=5kb.file bs=1k count=5
    $ dd if=/dev/urandom of=7mb.file bs=1M count=7
    $ touch zero.file
    $ : > alwayszero.file

Ar trebui să găsiți următoarele fișiere.

- „`5kb.file`” ce conține 5 Ko de zerouri.

- „`7mb.file`” ce conține 7 Mo de date aleatorii.

- "`zero.file`" poate fi un fișier de 0 octeți. Dacă a existat, `mtime` este actualizat, în timp ce conținutul și lungimea acestuia sunt păstrate.

- "`alwayszero.file`" este întotdeauna un fișier de 0 octeți. Dacă exista, `mtime` este actualizat și conținutul său este reinițializat.

### 9.8.8. Ștergerea întregului disc dur

There are several ways to completely erase data from an entire hard disk like device, e.g., USB flash drive at "`/dev/sda`".

| Atenție
Check your USB flash drive location with `mount`(8) first before executing commands here. The device pointed by "`/dev/sda`" may be SCSI hard disk or serial-ATA hard disk where your entire system resides.

Ștergeți tot conținutul discului punând datele la 0 cu următoarea comandă.

    # dd if=/dev/zero of=/dev/sda

Ștergeți totul suprascriind cu date aleatorii, ca mai jos.

    # dd if=/dev/urandom of=/dev/sda

Ștergeți totul suprascriind cu date aleatorii în mod foarte eficient, în felul următor.

    # shred -v -n 1 /dev/sda

Alternativ, puteți utiliza `badblocks`(8) cu opțiunea `-t random`.

Deoarece `dd`(1) este disponibil din shell-ul multor CD-uri Linux care pot fi pornite, cum ar fi CD-ul de instalare Debian, puteți șterge complet sistemul instalat executând o comandă de ștergere de pe un astfel de suport pe discul dur al sistemului, de exemplu, „`/dev/sda`”, „`/dev/sda`” etc.

### 9.8.9. Ștergerea zonei neutilizate a unui disc dur

Unused area on an hard disk (or USB flash drive), e.g. "`/dev/sdb1`" may still contain erased data themselves since they are only unlinked from the filesystem. These can be cleaned by overwriting them.

    # mount -t auto /dev/sdb1 /mnt/foo
    # cd /mnt/foo
    # dd if=/dev/zero of=junk
    dd: writing to `junk': No space left on device
    ...
    # sync
    # umount /dev/sdb1

| Avertisment
This is usually good enough for your USB flash drive. But this is not perfect. Most parts of erased filenames and their attributes may be hidden and remain in the filesystem.

### 9.8.10. Recuperarea fișierelor șterse, dar încă deschise

Chiar dacă ați șters accidental un fișier, atâta timp cât acel fișier este încă utilizat de o aplicație (în modul citire sau scriere), este posibil să recuperați un astfel de fișier.

De exemplu, încercați următoarele

    $ echo foo > bar
    $ less bar
    $ ps aux | grep ' less[ ]'
    bozo    4775  0.0  0.0  92200   884 pts/8    S+   00:18   0:00 less bar
    $ rm bar
    $ ls -l /proc/4775/fd | grep bar
    lr-x------ 1 bozo bozo 64 2008-05-09 00:19 4 -> /home/bozo/bar (deleted)
    $ cat /proc/4775/fd/4 >bar
    $ ls -l
    -rw-r--r-- 1 bozo bozo 4 2008-05-09 00:25 bar
    $ cat bar
    foo

Executați pe un alt terminal (când aveți pachetul `lsof` instalat) următoarele.

    $ ls -li bar
    2228329 -rw-r--r-- 1 bozo bozo 4 2008-05-11 11:02 bar
    $ lsof |grep bar|grep less
    less 4775 bozo 4r REG 8,3 4 2228329 /home/bozo/bar
    $ rm bar
    $ lsof |grep bar|grep less
    less 4775 bozo 4r REG 8,3 4 2228329 /home/bozo/bar (deleted)
    $ cat /proc/4775/fd/4 >bar
    $ ls -li bar
    2228302 -rw-r--r-- 1 bozo bozo 4 2008-05-11 11:05 bar
    $ cat bar
    foo

### 9.8.11. Căutarea tuturor legăturilor dure

Fișierele cu legături dure pot fi identificate prin „`ls -li`”.

    $ ls -li
    total 0
    2738405 -rw-r--r-- 1 root root 0 2008-09-15 20:21 bar
    2738404 -rw-r--r-- 2 root root 0 2008-09-15 20:21 baz
    2738404 -rw-r--r-- 2 root root 0 2008-09-15 20:21 foo

Atât „`baz`” cât și „`foo`” au un număr de legături de „2” (>1), ceea ce arată că au legături dure. Numărul lor de nod-i este comune „2738404”. Aceasta înseamnă că sunt același fișier legat dur. Dacă nu găsiți toate fișierele legate dur din întâmplare, le puteți căuta după nodul-i, de exemplu „2738404”, în felul următor.

    # find /path/to/mount/point -xdev -inum 2738404

### 9.8.12. Consum invizibil de spațiu pe disc

Toate fișierele șterse, dar deschise, ocupă spațiu pe disc, deși nu sunt vizibile din `du`(1) normal. Acestea pot fi listate împreună cu dimensiunea lor folosind următoarea comandă.

    # lsof -s -X / |grep deleted

## 9.9. Sfaturi pentru criptarea datelor

Având acces fizic la calculatorul dvs., oricine poate obține cu ușurință privilegii de root și acces la toate fișierele de pe calculatorul dvs. (consultați Secțiune 4.6.4, „Securizarea parolei root”). Aceasta înseamnă că sistemul de parole de autentificare nu poate proteja datele dvs. private și sensibile împotriva unui eventual furt al calculatorului. Pentru a face acest lucru, trebuie să implementați tehnologia de criptare a datelor. Deși GNU privacy guard (a se vedea Secțiune 10.3, „Data security infrastructure”) poate cripta fișiere, acest lucru necesită eforturi din partea utilizatorului.

Dm-crypt facilitează criptarea automată a datelor prin intermediul modulelor native ale nucleului Linux, cu eforturi minime din partea utilizatorului, utilizând device-mapper.

Tabel 9.25. Lista instrumentelor de criptare a datelor

pachet | popcon(popularitate) | dimensiune | descriere
--- | --- | --- | ---
`cryptsetup` | V:30, I:80 | 465 | instrumente pentru dispozitivul de blocuri criptat (dm-crypt / LUKS)
`cryptmount` | V:2, I:2 | 231 | instrumente pentru dispozitivul de blocuri criptat (dm-crypt / LUKS) cu accent pe montarea/demontarea de către utilizatorii normali
`fscrypt` | V:0, I:1 | 6471 | instrumente pentru criptarea sistemelor de fișiere Linux (fscrypt)
`libpam-fscrypt` | V:0, I:0 | 5589 | modul PAM pentru criptarea sistemului de fișiere Linux (fscrypt)

| Atenție
Criptarea datelor costă timp CPU etc. Datele criptate devin inaccesibile în cazul în care parola lor este pierdută. Vă rugăm să evaluați beneficiile și costurile.

| Notă
Întregul sistem Debian poate fi instalat pe un disc criptat de debian-installer (lenny sau mai nou) folosind dm-crypt/LUKS și initramfs.

| Indicație
Consultați Secțiune 10.3, „Data security infrastructure” pentru instrumentul utilitar de criptare a spațiului utilizatorului: GNU Privacy Guard.

### 9.9.1. Criptarea discurilor amovibile cu dm-crypt/LUKS

You can encrypt contents of removable mass devices, e.g. USB flash drive on "`/dev/sdx`", using dm-crypt/LUKS. You simply format it as the following.

    # fdisk /dev/sdx
    ... "n" "p" "1" "return" "return" "w"
    # cryptsetup luksFormat /dev/sdx1
    ...
    # cryptsetup open /dev/sdx1 secret
    ...
    # ls -l /dev/mapper/
    total 0
    crw-rw---- 1 root root  10, 60 2021-10-04 18:44 control
    lrwxrwxrwx 1 root root       7 2021-10-04 23:55 secret -> ../dm-0
    # mkfs.vfat /dev/mapper/secret
    ...
    # cryptsetup close secret

Apoi, acesta poate fi montat la fel ca unul normal pe „`/media/username/disk_label`”, cu excepția solicitării parolei (a se vedea Secțiune 10.1.7, „Removable storage device”) în mediul grafic de birou modern utilizând pachetul `udisks2`. Diferența este că toate datele scrise pe acesta sunt criptate. Introducerea parolei poate fi automatizată folosind «keyring» (a se vedea Secțiune 10.3.6, „Password keyring”).

În mod alternativ, puteți formata suportul în alt tip de sistem de fișiere, de exemplu, ext4 cu „`mkfs.ext4 /dev/mapper/sdx1`”. Dacă se utilizează în schimb btrfs, trebuie instalat pachetul `udisks2-btrfs`. Pentru aceste sisteme de fișiere, este posibil să fie necesară configurarea drepturilor de proprietate și a permisiunilor pentru fișiere.

### 9.9.2. Montarea discului criptat cu dm-crypt/LUKS

De exemplu, o partiție de disc criptată creată cu dm-crypt/LUKS pe „`/dev/sdc5`” de către programul de instalare Debian poate fi montată pe „`/mnt`” astfel:

    $ sudo cryptsetup open /dev/sdc5 ninja --type luks
    Enter passphrase for /dev/sdc5: ****
    $ sudo lvm
    lvm> lvscan
      inactive          '/dev/ninja-vg/root' [13.52 GiB] inherit
      inactive          '/dev/ninja-vg/swap_1' [640.00 MiB] inherit
      ACTIVE            '/dev/goofy/root' [180.00 GiB] inherit
      ACTIVE            '/dev/goofy/swap' [9.70 GiB] inherit
    lvm> lvchange -a y /dev/ninja-vg/root
    lvm> exit
      Exiting.
    $ sudo mount /dev/ninja-vg/root /mnt

## 9.10. Nucleul

Debian distribuie Nucleul Linux modularizat ca pachete pentru arhitecturile acceptate.

Dacă citiți această documentație, probabil că nu trebuie să compilați singur nucleul Linux.

### 9.10.1. Parametrii nucleului

Multe caracteristici Linux sunt configurabile prin intermediul parametrilor nucleului, după cum urmează.

- Parametrii nucleului inițializați de încărcătorul de pornire (a se vedea Secțiune 3.1.2, „Etapa 2: încărcătorul de pornire”)

- Parametrii nucleului modificați de `sysctl`(8) în timpul execuției pentru cei accesibili prin sysfs (a se vedea Secțiune 1.2.12, „procfs și sysfs”)

- Parametrii modulului stabiliți prin argumentele lui `modprobe`(8) atunci când un modul este activat (a se vedea Secțiune 9.7.3, „Montarea fișierului imagine disc”)

Consultați „The Linux kernel user’s and administrator’s guide » The kernel’s command-line parameters" pentru detalii.

### 9.10.2. Antetele nucleului

Majoritatea programelor normale nu au nevoie de antete ale nucleului și, de fapt, se pot întrerupe dacă le utilizați direct pentru compilare. Acestea ar trebui compilate pe baza antetelor din „`/usr/include/linux`” și „`/usr/include/asm`” furnizate de pachetul `libc6-dev` (creat din pachetul sursă `glibc`) pe sistemul Debian.

| Notă
Pentru compilarea unor programe specifice nucleului, cum ar fi modulele nucleului din sursă externă și demonul automounter (`amd`), trebuie să includeți în linia de comandă ruta către antetele nucleului corespunzător, de exemplu „`-I/usr/src/linux-particular-version/include/`”.

### 9.10.3. Compilarea nucleului și a modulelor aferente

Debian are propria sa metodă de compilare a nucleului și a modulelor aferente.

Tabel 9.26. Lista pachetelor cheie care trebuie instalate pentru recompilarea nucleului pe sistemul Debian

pachet | popcon(popularitate) | dimensiune | descriere
--- | --- | --- | ---
`build-essential` | I:504 | 17 | pachete esențiale pentru construirea pachetelor Debian: `make`, `gcc`, …
`bzip2` | V:168, I:972 | 114 | instrumente de comprimare și decomprimare pentru fișiere bz2
`libncurses5-dev` | I:40 | 6 | biblioteci pentru dezvoltatori și documente pentru ncurses
`git` | V:382, I:597 | 50172 | git: sistem distribuit de control al reviziei utilizat de nucleul Linux
`fakeroot` | V:31, I:507 | 225 | furnizează mediul fakeroot pentru construirea pachetului ca non-root
`initramfs-tools` | V:479, I:988 | 52 | instrument pentru a construi un initramfs (specific Debian)
`dkms` | V:74, I:146 | 235 | dynamic kernel module support (DKMS) (generic)
`module-assistant` | V:0, I:14 | 391 | instrument de ajutor pentru crearea pachetului de module (specific Debian)
`devscripts` | V:5, I:33 | 2770 | scripturi de ajutor pentru un întreținător de pachete Debian (specific Debian)

Dacă utilizați `initrd` în Secțiune 3.1.2, „Etapa 2: încărcătorul de pornire”, asigurați-vă că citiți informațiile aferente în `initramfs-tools`(8), `update-initramfs`(8), `mkinitramfs`(8) și `initramfs.conf`(5).

| Avertisment
Nu puneți legături simbolice către directoarele din arborele sursă (de exemplu, „`/usr/src/linux*`”) din „`/usr/include/linux`” și „`/usr/include/asm`” atunci când compilați sursa nucleului Linux; (unele documente învechite sugerează acest lucru).

| Notă

La compilarea celui mai recent nucleu Linux pe sistemul Debian `stable`, poate fi necesară utilizarea celor mai recente instrumente retro-adaptate din Debian `unstable`.

`module-assistant`(8) (sau forma sa scurtă `m-a`) ajută utilizatorii să construiască și să instaleze cu ușurință pachetul (pachetele) de module pentru unul sau mai multe nuclee personalizate.

dynamic kernel module support (DKMS) este un nou cadru independent de distribuție conceput pentru a permite actualizarea modulelor individuale ale nucleului fără schimbarea întregului nucleu. Acest lucru este utilizat pentru întreținerea modulelor din afara arborelui. De asemenea, acest lucru facilitează foarte mult reconstruirea modulelor pe măsură ce actualizați nucleele.

### 9.10.4. Compilarea sursei nucleului: Recomandarea echipei Debian Kernel

Pentru a construi pachete binare de nucleu personalizate din sursa de nucleu din amonte, trebuie să utilizați ținta „`deb-pkg`” furnizată de acesta.

    $ sudo apt-get build-dep linux
    $ cd /usr/src
    $ wget https://mirrors.edge.kernel.org/pub/linux/kernel/v6.x/linux-version.tar.xz
    $ tar --xz -xvf linux-version.tar.xz
    $ cd linux-version
    $ cp /boot/config-version .config
    $ make menuconfig
     ...
    $ make deb-pkg

| Indicație
Pachetul linux-source-version furnizează sursa nucleului Linux cu plasturi(corecții) Debian ca „`/usr/src/linux-version.tar.bz2`”.

Pentru a construi pachete binare specifice din pachetul sursă al nucleului Debian, trebuie să utilizați obiectivele „`binary-arch_architecture_featureset_flavour`” din „`debian/rules.gen`”.

    $ sudo apt-get build-dep linux
    $ apt-get source linux
    $ cd linux-3.*
    $ fakeroot make -f debian/rules.gen binary-arch_i386_none_686

Mai multe informații:

- Debian Wiki: KernelFAQ

- Debian Wiki: DebianKernel

- Debian Linux Kernel Handbook: https://kernel-handbook.debian.net

### 9.10.5. Controlori hardware și firmware

Controlorul hardware este codul care rulează pe CPU-urile principale ale sistemului țintă. Majoritatea controlorilor hardware sunt disponibili acum ca software liber și sunt incluși în pachetele normale de nucleu Debian în zona `main`.

- Controlor GPU

  - Controlor GPU Intel (`main`)

  - Controlor GPU AMD/ATI (`main`)

  - Controlor GPU NVIDIA (`main` pentru controlorul nouveau și `non-free` pentru controlorii numai-binari asigurați de producător.)

Firmware-ul este codul sau datele încărcate pe dispozitivul atașat sistemului țintă (de exemplu, microcode CPU, codul de redare care rulează pe GPU sau FPGA / CPLD date, ...). Unele pachete firmware sunt disponibile ca software gratuit, dar multe pachete firmware nu sunt disponibile ca software gratuit deoarece conțin date binare fără sursă. Instalarea acestor date de firmware este esențială pentru ca dispozitivul să funcționeze conform așteptărilor.

- Pachetele de date firmware care conțin date încărcate în memoria volatilă a dispozitivului țintă.

  - firmware-linux-free (`main`)

  - firmware-linux-nonfree (`non-free-firmware`)

  - firmware-linux-* (`non-free-firmware`)

  - *-firmware (`non-free-firmware`)

  - intel-microcode (`non-free-firmware`)

  - amd64-microcode (`non-free-firmware`)

- Pachetele de programe de actualizare a firmware-ului care actualizează datele din memoria nevolatilă a dispozitivului țintă.

  - fwupd (`main`): Demon de actualizare a firmware-ului care descarcă datele firmware de la Linux Vendor Firmware Service.

  - gnome-firmware (`main`): interfață grafică GTK pentru «fwupd»

  - plasma-discover-backend-fwupd (`main`): interfață grafică Qt pentru «fwupd»

Vă rugăm să rețineți că accesul la pachetele `non-free-firmware` sunt furnizate de mediile de instalare oficiale pentru a oferi utilizatorului o experiență de instalare funcțională începând cu Debian 12 Bookworm. Zona `non-free-firmware` este descrisă în Secțiune 2.1.5, „Noțiuni de bază despre arhiva Debian”.

Vă rugăm să rețineți, de asemenea, că datele firmware descărcate de fwupd de la Linux Vendor Firmware Service și încărcate în nucleul Linux care rulează pot fi `non-free`.

## 9.11. Sistem virtualizat

Utilizarea sistemului virtualizat ne permite să rulăm mai multe instanțe ale sistemului simultan pe un singur hardware.

| Indicație
Consultați Debian wiki on SystemVirtualization.

### 9.11.1. Instrumente de virtualizare și emulare

Există mai multe platforme de virtualizare și instrumente de emulare.

- Pachete complete de emulare a hardware-ului „hardware emulation” precum cele instalate de metapachetul games-emulator

- În principal emulație la nivel de CPU cu unele emulări de dispozitive de In/Ieș, cum ar fi QEMU

- În principal virtualizare la nivel de CPU cu unele emulări de dispozitive de In/Ieș, cum ar fi Kernel-based Virtual Machine (KVM)

- Virtualizarea containerelor la nivel de sistem de operare cu suport la nivel de nucleu, cum ar fi LXC (Linux Containers), Docker, `systemd-nspawn`(1), ...

- Virtualizarea accesului la sistemul de fișiere la nivel de sistem de operare cu suprascrierea apelului bibliotecii de sistem pe ruta fișierului, cum ar fi chroot

- Virtualizarea accesului la sistemul de fișiere la nivel de sistem de operare cu suprascrierea apelului bibliotecii de sistem privind proprietatea asupra fișierului, cum ar fi fakeroot

- Emularea API a sistemului de operare, cum ar fi Wine

- Virtualizarea la nivel de interpret cu selectarea executabilului și suprascrierea bibliotecilor în timp de execuție, cum ar fi virtualenv și venv pentru Python

Virtualizarea containerelor utilizează Secțiune 4.7.5, „Caracteristici de securitate Linux” și este tehnologia de bază a Secțiune 7.7, „Cutia cu nisip (sandbox)”.

Iată câteva pachete care vă vor ajuta să configurați sistemul virtualizat.

Tabel 9.27. Lista instrumentelor de virtualizare

pachet | popcon(popularitate) | dimensiune | descriere
--- | --- | --- | ---
`coreutils` | V:892, I:999 | 18457 | Instrumente GNU de bază care conțin `chroot`(8)
`util-linux` | V:897, I:999 | 4384 | utiități de sistem diverse care conțin `unshare`(1)
`systemd-container` | V:72, I:76 | 2276 | instrumente systemd container/nspawn care conțin `systemd-nspawn`(1)
`schroot` | V:5, I:7 | 2627 | instrument specializat pentru executarea pachetelor binare Debian în chroot
`sbuild` | V:1, I:4 | 157 | instrument pentru construirea de pachete binare Debian din surse Debian
`debootstrap` | V:4, I:46 | 330 | creează și pornește un sistem Debian de bază (scris în sh)
`mmdebstrap` | V:5, I:10 | 574 | creează și pornește un sistem Debian (scris în Perl)
`cdebootstrap` | V:0, I:1 | 114 | creează și pornește un sistem Debian (scris în C)
`cloud-image-utils` | V:0, I:14 | 66 | utilități de gestionare a imaginilor în cloud
`cloud-guest-utils` | V:4, I:18 | 71 | utilități pentru invitați în cloud
`virt-manager` | V:12, I:49 | 2310 | Gestionar mașină virtuală: aplicație de mediu grafic de birou pentru gestionarea mașinilor virtuale
`libvirt-clients` | V:49, I:72 | 1155 | programe pentru biblioteca libvirt
`incus` | V:0, I:2 | 21 | Incus: container de sistem și gestionar de mașini virtuale
`podman` | V:25, I:29 | 81828 | podman: motor pentru a rula containere bazate pe OCI în Pods
`podman-docker` | V:2, I:2 | 275 | motor pentru a rula containere bazate pe OCI în Pods - învăluitor pentru docker
`docker.io` | V:44, I:47 | 95958 | docker: mediu de execuție de containere Linux
`games-emulator` | I:0 | 21 | games-emulator: emulatoare Debian pentru jocuri
`bochs` | V:0, I:0 | 8180 | Bochs: emulator PC IA-32
`qemu-system` | I:22 | 80 | QEMU: binare de emulare completă a sistemului
`qemu-user` | V:5, I:9 | 464225 | QEMU: binare de emulare în modul utilizator
`qemu-utils` | V:14, I:109 | 12157 | QEMU: utilități
`qemu-system-x86` | V:53, I:93 | 67511 | KVM: virtualizare completă pe hardware x86 cu hardware-assisted virtualization
`virtualbox` | V:3, I:4 | 151525 | VirtualBox: soluție de virtualizare x86 pe i386 și amd64
`gnome-boxes` | V:1, I:6 | 6847 | Boxes: aplicație GNOME simplă pentru accesarea sistemelor virtuale
`xen-tools` | V:0, I:1 | 719 | instrumente pentru gestionarea serverului virtual debian XEN
`wine` | V:14, I:57 | 204 | Wine: implementarea API Windows (suita standard)
`dosbox` | V:1, I:13 | 2697 | DOSBox: emulator x86 cu grafică Tandy/Herc/CGA/EGA/VGA/SVGA, sunet și DOS
`lxc` | V:9, I:12 | 1626 | Linux containers user space tools
`python3-venv` | V:8, I:136 | 6 | venv pentru crearea de medii virtuale python (biblioteca de sistem)
`python3-virtualenv` | V:8, I:41 | 417 | virtualenv pentru crearea de medii python virtuale izolate
`pipx` | V:7, I:43 | 3613 | pipx pentru instalarea aplicațiilor python în medii izolate

Consultați articolul Wikipedia Compararea platformelor de mașini virtuale pentru o comparație detaliată a diferitelor soluții de virtualizare a platformelor.

### 9.11.2. Fluxul de lucru pentru virtualizare

| Notă
Nucleele Debian implicite acceptă KVM de la `lenny`.

Fluxul de lucru tipic pentru virtualizare implică mai multe etape.

- Creați un sistem de fișiere gol (un arbore de fișiere sau o imagine de disc).

  - Arborele de fișiere poate fi creat prin „`mkdir -p /ruta/la/chroot`”.

  - Fișierul imagine de disc brut poate fi creat cu `dd`(1) (a se vedea Secțiune 9.7.1, „Crearea fișierului imagine de disc” și Secțiune 9.7.5, „Crearea fișierului imagine de disc gol”).

  - `qemu-img`(1) poate fi utilizat pentru a crea și converti fișiere imagine de disc acceptate de QEMU.

  - Formatul de fișier brut și VMDK poate fi utilizat ca format comun între instrumentele de virtualizare.

- Montați imaginea discului cu `mount`(8) pe sistemul de fișiere (opțional).

  - Pentru fișierul imagine de disc brut, montați-l ca dispozitiv loop device sau dispozitiv device mapper (a se vedea Secțiune 9.7.3, „Montarea fișierului imagine disc”).

  - Pentru imaginile de disc acceptate de QEMU, montați-le ca network block device (vedeți Secțiune 9.11.3, „Montarea fișierului imagine al discului virtual”).

- Populați sistemul de fișiere țintă cu datele de sistem necesare.

  - Utilizarea unor programe precum `debootstrap` și `cdebootstrap` ajută la acest proces (a se vedea Secțiune 9.11.4, „Sistemul chroot”).

  - Utilizați programe de instalare ale sistemelor de operare sub emulația sistemului complet.

- Rulați un program într-un mediu virtualizat.

  - chroot oferă un mediu virtualizat de bază suficient pentru a compila programe, a rula aplicații de consolă și a rula demoni în el.

  - QEMU oferă emulare CPU multi-platformă.

  - QEMU cu KVM oferă emulare completă a sistemului prin virtualizare asistată de hardware hardware-assisted virtualization.

  - VirtualBox oferă emulare completă a sistemului pe i386 și amd64 cu sau fără virtualizare asistată de hardware hardware-assisted virtualization.

### 9.11.3. Montarea fișierului imagine al discului virtual

Pentru fișierul imagine de disc brut, vedeți Secțiune 9.7, „Imaginea discului”.

Pentru alte fișiere imagine de disc virtual, puteți utiliza `qemu-nbd`(8) pentru a le exporta utilizând protocolul network block device (dispozitiv de blocuri din rețea) și a le monta utilizând modulul nucleului `nbd`.

`qemu-nbd`(8) acceptă formatele de disc acceptate de QEMU: raw, qcow2, qcow, vmdk, vdi, bochs, cow (user-mode Linux copy-on-write), parallels, dmg, cloop, vpc, vvfat (VFAT virtual) și host_device.

Dispozitivul network block device poate accepta partiții în același mod ca dispozitivul loop device (consultați Secțiune 9.7.3, „Montarea fișierului imagine disc”). Puteți monta prima partiție din „`disk.img`” după cum urmează.

    # modprobe nbd max_part=16
    # qemu-nbd -v -c /dev/nbd0 disk.img
    ...
    # mkdir /mnt/part1
    # mount /dev/nbd0p1 /mnt/part1

| Indicație
Puteți exporta numai prima partiție din „`disk.img`” utilizând opțiunea „`-P 1`” la `qemu-nbd`(8).

### 9.11.4. Sistemul chroot

Dacă doriți să încercați un nou mediu Debian de la o consolă terminal, vă recomand să utilizați chroot. Acest lucru vă permite să rulați aplicații de consolă Debian `unstable` și `testing` fără riscurile obișnuite asociate și fără repornire. `chroot`(8) este cea mai de bază modalitate.

| Atenție
Exemplele de mai jos presupun că atât sistemul părinte, cât și sistemul chroot au aceeași arhitectură CPU `amd64`.

Deși puteți crea manual un mediu `chroot`(8) utilizând `debootstrap`(1), acest lucru necesită eforturi netriviale.

Pachetul sbuild pentru a construi pachete Debian din sursă utilizează mediul chroot gestionat de pachetul schroot. Acesta vine cu scriptul ajutător `sbuild-createchroot`(1). Să învățăm cum funcționează executându-l după cum urmează.

    $ sudo mkdir -p /srv/chroot
    $ sudo sbuild-createchroot -v --include=eatmydata,ccache unstable /srv/chroot/unstable-amd64-sbuild http://deb.debian.org/debian
     ...

Vedeți cum `debootstrap`(8) completează datele sistemului pentru mediul `unstable` sub „`/srv/chroot/unstable-amd64-sbuild`” pentru un sistem de compilare minim.

Vă puteți conecta la acest mediu utilizând `schroot`(1).

    $ sudo schroot -v -c chroot:unstable-amd64-sbuild

Vedeți cum este creat un shell de sistem care rulează în mediul `unstable`.

| Notă
Fișierul „`/usr/sbin/policy-rc.d`” care iese întotdeauna cu 101 împiedică pornirea automată a programelor demon pe sistemul Debian. Consultați „`/usr/share/doc/init-system-helpers/README.policy-rc.d.gz`”.

| Notă
Unele programe sub chroot pot necesita acces la mai multe fișiere din sistemul părinte pentru a funcționa decât oferă `sbuild-createchroot` conform celor de mai sus. De exemplu, „`/sys`”, „`/etc/passwd`”, „`/etc/group`”, „`/var/run/utmp`”, „`/var/log/wtmp`” etc. pot necesita să fie montatecu opțiunea „--bind” sau copiate.

| Indicație
Pachetul `sbuild` ajută la construirea unui sistem chroot și construiește un pachet în chroot folosind `schroot` ca sistem de gestionare și manipulare a datelor. Este un sistem ideal pentru a verifica dependențele de construcție. Vedeți mai multe despre sbuild la Debian wiki și sbuild exemplu de configurare în „Guide for Debian Maintainers”.

| Indicație
Comanda `systemd-nspawn`(1) ajută la rularea unei comenzi sau a unui sistem de operare într-un container de dimensiuni reduse în moduri similare cu `chroot`. Este mai puternic deoarece utilizează spații de nume pentru a virtualiza complet arborele de procese, IPC, numele de gazdă, numele de domeniu și, opțional, bazele de date de rețea și de utilizator. Consultați systemd-nspawn.

### 9.11.5. Mai multe sisteme de medii de birou

Dacă doriți să încercați un nou mediu grafic de birou al oricărui sistem de operare, vă recomand să utilizați QEMU sau KVM pe un sistem Debian `stable` pentru a rula mai multe sisteme de mediu de birou în siguranță utilizând virtualizare. Acestea vă permit să rulați orice aplicații de mediu de birou, inclusiv cele din Debian `unstable` și `testing`, fără riscurile obișnuite asociate cu acestea și fără repornire.

Deoarece QEMU pur este foarte lent, se recomandă accelerarea acestuia cu KVM atunci când sistemul gazdă îl acceptă.

Gestionarul de mașini virtuale cunoscut și ca `virt-manager` este un instrument cu interfață grafică, convenabil pentru gestionarea mașinilor virtuale KVM prin libvirt.

Imaginea discului virtual „`virtdisk.qcow2`” care conține un sistem Debian pentru QEMU poate fi creată utilizând debian-installer: Small CDs după cum urmează.

    $ wget https://cdimage.debian.org/debian-cd/5.0.3/amd64/iso-cd/debian-503-amd64-netinst.iso
    $ qemu-img create -f qcow2 virtdisk.qcow2 5G
    $ qemu -hda virtdisk.qcow2 -cdrom debian-503-amd64-netinst.iso -boot d -m 256
    ...

| Indicație
Rularea altor distribuții GNU/Linux precum Ubuntu și Fedora sub virtualizare este o modalitate excelentă de a învăța sfaturi de configurare. Alte sisteme de operare proprietare pot fi rulate foarte bine și sub această virtualizare GNU/Linux.

Vedeți mai multe sfaturi la Debian wiki: SystemVirtualization.

[2] Exemple de personalizare mai elaborate: „Vim Galore”, „sensible.vim”, ...

[3] vim-pathogen a fost popular.

Cap. 8. I18N și L10N |  | Cap. 10. Gestionarea datelor