Git Basics - Come gestire in modo efficiente il codice del progetto

Git è il sistema di controllo di versione (VCS) più popolare utilizzato dagli sviluppatori e dai team di sviluppo per tenere traccia delle modifiche apportate al codice sorgente. In effetti, è il sistema di controllo della versione più popolare utilizzato in DevOps.

Un sistema di controllo di versione è un software che tiene traccia o registra le modifiche apportate al codice software nel tempo in un database speciale denominato repository. Con Git, puoi tenere traccia della cronologia del progetto e vedere quali modifiche sono state apportate e chi le ha apportate.

È anche possibile eseguire il rollback delle modifiche per ripristinare il codice originale. Inoltre, Git consente a più persone di collaborare allo stesso progetto indipendentemente dalla loro posizione.

I sistemi di controllo di versione possono essere classificati in due: centralizzati e distribuiti.
[lwptoc]

Che cos'è un sistema di controllo di versione centralizzato

In un sistema centralizzato, tutti gli utenti si connettono a un server centrale per ottenere una copia del codice software e condividerla con gli altri. Esempi di sistemi centralizzati di controllo della versione includono Subversion, distribuito sotto la licenza Apache e Microsoft Team Foundation Server (Microsoft TFS).

Lo svantaggio del VCS centralizzato è l'esistenza di un singolo punto di errore. Quando il server centrale si interrompe, i membri del team non possono più collaborare al progetto.

Che cos'è un sistema di controllo di versione distribuito

Con i sistemi distribuiti, ogni membro del team può avere una copia del progetto di codice sul proprio computer locale. Se il server centrale subisce tempi di inattività, gli utenti possono sincronizzare il codice software con altri senza problemi.

Esempi di sistemi di controllo di versione distribuiti includono Git e Mercurial.

Perché usare Git?

Di tutti i sistemi di controllo di versione che abbiamo menzionato, Git è il VCS più popolare e utilizzato. E per buone ragioni. È gratuito e open source, scalabile, veloce e affidabile.

Puoi tenere traccia delle modifiche apportate al codice e collaborare facilmente a un progetto con altri membri del team. Inoltre, operazioni come la ramificazione e l'unione sono molto più semplici in Git che in Mercurial o in qualsiasi altro VCS.

Al giorno d'oggi, Git è onnipresente ed è utilizzato sia dalle piccole aziende che dalle grandi imprese per gestire in modo efficiente il codice software. Per questo motivo, è una delle competenze più richieste dagli sviluppatori o da coloro che si avvicinano allo sviluppo di software.

Quindi, se stai cercando di ottenere un lavoro come sviluppatore di software, tieni presente che Git è un prerequisito. È necessario avere una conoscenza e una comprensione approfondite di questo strumento del sistema di controllo della versione.

In questo tutorial, ti guideremo attraverso le nozioni di base di Git e come gestire in modo efficiente il tuo codice.

Introduzione a Git e GitHub

Non possiamo parlare di Git senza menzionare GitHub. Questi due sono intrecciati e spesso vanno di pari passo. In effetti, molte persone pensano che Git e GitHub siano la stessa cosa. Tuttavia, si tratta di due cose separate che si integrano l'una con l'altra.

GitHub è una piattaforma di hosting di codice per i repository Git. Si tratta essenzialmente di un sito Web in cui sviluppatori e project manager ospitano i loro progetti software.

Consente ai membri del team o agli sviluppatori di coordinare e tenere traccia delle modifiche apportate al codice, nonché di apportare aggiornamenti dove necessario. In tal modo, GitHub promuove la collaborazione, la trasparenza e aiuta i membri del team a lavorare da qualsiasi luogo e a rimanere aggiornati con le ultime modifiche apportate al codice.

In GitHub i pacchetti possono essere pubblicati pubblicamente, consentendo l'accesso al mondo esterno, o privatamente all'interno dei membri del team. Una volta condiviso pubblicamente, gli utenti possono scaricare il codice e provarlo sui propri personal computer.

In sintesi, GitHub è una piattaforma di hosting di codice online che fornisce un'interfaccia utente interessante e ti consente di ospitare repository Git remoti e lavorare in collaborazione con altri sviluppatori da qualsiasi luogo.

D'altra parte, Git è ciò che gestisce le operazioni di controllo della versione come il push e l'unione del codice, l'esecuzione di commit, la clonazione di repository, ecc. Esploriamo ora vari comandi Git che puoi utilizzare per lavorare con GitHub.

Come installare Git su Linux

Prima di iniziare a utilizzare Git, installiamolo. Se stai utilizzando Ubuntu o una distribuzione basata su Debian, esegui i seguenti comandi apt per installarla.

$ sudo apt update
sudo apt install git -y

Per le distribuzioni basate su Red Hat come RHEL, Fedora, CentOS Stream, AlmaLinux e Rocky Linux, eseguire i seguenti comandi dnf:

$ sudo dnf update
sudo dnf install git -y

Per confermare che Git è installato, eseguire il comando:

$ git --version

git version 2.34.1

Inizializzazione di un repository Git

Il passo iniziale nell'utilizzo di git consiste nell'inizializzare un repository git, che consiste essenzialmente nel convertire una directory sul sistema locale in un repository git in cui verranno archiviati tutti i file di progetto e il codice prima di essere inviati a GitHub.

Per dimostrarlo, creeremo una directory chiamata test_repo e navigheremo al suo interno.

$ mkdir test_repo
cd test_repo

Per inizializzare il repository, eseguire il seguente comando:

$ git init

Riceverai una serie di messaggi di suggerimento e alla fine dell'output vedrai una notifica che indica che il repository Git è stato inizializzato su un ramo che, per impostazione predefinita, è chiamato master.

Eseguire il commit delle modifiche nel repository Git

Una volta che una directory è stata inizializzata, viene creata una directory nascosta chiamata .git, che contiene tutti i file necessari a Git per tenere traccia delle modifiche apportate al codice. Per visualizzare questa directory, eseguire il comando ls con le opzioni -la come mostrato.

$ ls -la

Il rilevamento di un progetto avviene solo dopo che le modifiche sono state confermate per la prima volta. Su questo punto torneremo più avanti.

Configurazione del repository Git

Una volta inizializzato il repository Git, il passo successivo è impostare alcune variabili di configurazione per Git. Aggiungeremo un nome utente e un indirizzo e-mail che saranno associati ai commit.

Per aggiungere un nome utente e un indirizzo e-mail a tutti i commit dell'utente corrente, eseguire i comandi seguenti. Assicurati di fornire il tuo nome e indirizzo e-mail preferiti.

$ git config --global user.name "your_name"
git config --global user.email "email_address"

Per confermare le variabili impostate, eseguire il comando:

$ git config --list

Aggiungere un file a un repository Git

Per apportare modifiche al repository git, eseguire prima il comando git add, seguito da git commit. Il comando git add aggiunge file all'area di staging. Si tratta essenzialmente di un'area speciale in cui proponiamo le modifiche per il prossimo commit.

Nella nostra configurazione, abbiamo un file Python chiamato app.py. Per aggiungere questo file all'area di staging, eseguiremo il seguente comando.

$ git add app.py

Se disponi di più file di progetto, puoi aggiungerli tutti in una volta sola come mostrato.

$ git add -A
OR
git add --all

Dopo aver aggiunto tutti i file all'area di staging, esegui il commit nel repository utilizzando il comando git commit. Un commit è come scattare un'istantanea del tuo progetto.

$ git commit -m "Some Message"

L'output seguente mostra che è stato eseguito correttamente il commit delle modifiche nel repository Git.

Per controllare lo stato dei commit, eseguire il comando:

$ git status

Se non ci sono commit in sospeso, riceverai la notifica che non c'è nulla di cui eseguire il commit.

Ora, creiamo altri due file e controlliamo lo stato dei commit.

$ echo "Hello there" > file1.txt
echo "Let us learn Git" > file2.txt

Quindi, visualizzare lo stato dell'area di gestione temporanea.

$ git status

Questa volta, i file appena aggiunti appariranno in rosso e saranno contrassegnati come "non tracciati". Affinché Git possa tracciarli, dovrai aggiungerli all'area di staging.

Per aggiungere tutti i file in una volta sola, esegui il comando:

$ git add .

Successivamente, esegui il commit delle modifiche apportate.

$ git commit -m "Second Commit"

Ora, proviamo qualcosa di più ambizioso. Modificheremo un file.

$ echo "Git is a popular Version Control System" >> file2.txt

Ancora una volta, il file appare in rosso poiché non è stato eseguito il commit delle modifiche apportate.

Ancora una volta, è necessario aggiungere il file modificato all'area di staging.

$ git add file2.txt
git status

Quando si controlla lo stato dell'area di gestione temporanea, il file viene visualizzato in verde ed è pronto per essere confermato.

Rimuovi il file dal repository Git

Supponiamo di renderci conto che non abbiamo più bisogno di file2.txt nel nostro progetto poiché ha codice inutilizzato. È possibile rimuoverlo utilizzando il comando rm come mostrato.

$ rm file2.txt

Quando controlli lo stato, vedi che il file eliminato è contrassegnato in rosso e che la modifica non è stata ancora salvata.

$ git status

Abbiamo rimosso file2.txt dalla nostra directory di lavoro. Tuttavia, esiste ancora nell'area di sosta. Per confermarlo, eseguire il comando:

$ git ls-files

Per eseguire l'eliminazione temporanea, eseguire il comando git add come illustrato

$ git add file2.txt

Ancora una volta, elenca i file nell'area di staging.

$ git ls-files

Questa volta, si noterà che file2.txt non esiste più nell'area di staging. Quando si controlla lo stato, è possibile vedere che la modifica è pronta per essere salvata.

Quindi ora impegniamoci per il cambiamento apportato.

$ git commit -m "Remove unused code files"

Invio del repository locale su GitHub

Con il repository locale pronto, ora puoi scegliere di inviare il tuo progetto a GitHub per la collaborazione e per consentire ad altri utenti di accedere al tuo progetto.

Ma andiamo con ordine. Se non ne hai già uno, devi creare un account GitHub.

Successivamente, è necessario creare un nuovo repository vuoto. Questo è il repository in cui si invierà il repository locale. Quindi, fai clic sul pulsante "Nuovo".

Inserisci il nome del repository e impostalo su "Pubblico". Puoi scegliere di inizializzare un file README o meno. Si tratta di un file che descrive brevemente l'oggetto del codice. Questo non ha molta importanza per ora.

Quindi fare clic sul pulsante "Crea repository" per creare il repository con i dettagli forniti. In questo esempio, abbiamo creato un repository chiamato 'my-test-project'.

Verrà fornita una configurazione rapida che include un collegamento al repository appena creato e istruzioni su come inviare il repository locale a GitHub.

Il passaggio successivo consiste nell'abilitare l'autenticazione a GitHub sulla riga di comando utilizzando le chiavi SSH.

Per farlo, fai clic sull'icona del tuo profilo nell'angolo destro e seleziona "Impostazioni".

Quindi, vai alle chiavi "SSH e GPG", quindi fai clic su "Nuova chiave SSH".

Quindi, copia la chiave SSH pubblica e fornisci un titolo significativo alla tua chiave. Quindi premere "Aggiungi chiave SSH".

Tutto è pronto ora per inviare il tuo repository su GitHub. Aggiungi il repository GitHub remoto utilizzando la sintassi del comando git remote add.

$ git remote add origin [REMOTE REPOSITORY URL HERE]

Nella sintassi precedente, 'remote' sta per la versione del repository remoto mentre 'origin' è il nome dato a un server remoto.

Nel nostro caso, il comando apparirà come mostrato.

$ git remote add origin https://github.com/kodewise/my-test-project.git

Successivamente, esegui il comando git push per eseguire il push del repository locale su GitHub. In questo caso, il master è il nome predefinito del ramo.

$ git push -u origin master

Quando visiti il tuo repository su Github, vedrai tutti i tuoi file di progetto.

In futuro, se si desidera aggiungere un nuovo file al repository, è sufficiente ripetere gli stessi passaggi per aggiungere il file all'area di staging, eseguire il commit e inviare le modifiche al repository.

$ git add -A
git commit -m 'Added my project'
git push -u origin main

Aggiorna il repository locale con le modifiche apportate su GitHub

Il comando git pull viene utilizzato per aggiornare il repository locale con le modifiche upstream nel repository remoto. In sostanza, scarica le modifiche apportate al codice su GitHub e aggiorna di conseguenza il repository locale sul sistema. Combina i comandi git fetch e git merge.

In questo esempio, abbiamo modificato il file README sul repository remoto ospitato su GitHub. Per assicurarci di avere la stessa copia sul nostro repository locale, eseguiremo il comando:

$ git pull https://github.com/kodewise/my-test-project.git

Clonazione di un repository Git

Il comando git clone scarica una copia esatta dei file del progetto in un repository GitHub. È possibile clonare un repository pubblico su qualsiasi sistema o directory utilizzando la seguente sintassi.

$ git clone [REMOTE REPOSITORY URL HERE]

Nella pagina del progetto GitHub, fai clic su "Codice" e copia l'URL come evidenziato di seguito.

Quindi clona il repository Github come mostrato.

$ git clone https://github.com/kodewise/my-test-project.git

In questo modo viene scaricato l'intero repository insieme ai file di progetto.

Conclusione

In questo tutorial Git, abbiamo introdotto git e dimostrato i comandi di base utilizzati per creare e gestire i file in un repository Git. Infine, ti abbiamo illustrato come eseguire il push del tuo repository su GitHub per la collaborazione. Per ora è tutto. Ci auguriamo che questo tutorial ti sia stato utile.