Come installare Gitea Code Hosting Service su Fedora 34

Su questa pagina

Prerequisiti
Passaggio 1: configurazione del firewall
Passaggio 2 - Installa Git
1. Configura Git
1. Crea un file di servizio Systemd
Gitea è una soluzione di hosting di codice open source basata sulla piattaforma Git. È scritto nella lingua Go. Include un editor di file di repository, tracciamento dei problemi, richieste pull, gestione degli utenti, notifiche, wiki integrato, supporto LFS, hook Git e molto altro.
È un'applicazione leggera. Pertanto, può essere installato su sistemi a bassa potenza. Se stai cercando una piattaforma Git self-hosted con una piattaforma di memoria più piccola, dovresti dare un'occhiata a Gitea.
Questo articolo tratterà come installare e configurare Gitea su Fedora 34 e come configurare il tuo primo repository Git. Gitea può essere installato da sorgente, binario, pacchetto docker o pacchetto. Per il nostro tutorial, lo installeremo da binario.
Prerequisiti
- A server running Fedora 34.
- A non-root sudo user.
- SELinux Disabled.
- Make sure everything is updated.
```
$ sudo dnf update
```
Passaggio 1: configurare il firewall
Il primo passo è configurare il firewall. Il server Fedora viene fornito con Firewalld firewall.
Controlla se il firewall è in esecuzione.
```
$ sudo firewall-cmd --state
```
Dovresti ottenere il seguente output.
```
running
```
Controlla gli attuali servizi/porte consentiti.
```
$ sudo firewall-cmd --permanent --list-services
```
Dovrebbe mostrare il seguente output.
```
dhcpv6-client mdns ssh
```
Consenti porte HTTP e HTTPS.
```
$ sudo firewall-cmd --permanent --add-service=http
$ sudo firewall-cmd --permanent --add-service=https
```
Ricontrolla lo stato del firewall.
```
$ sudo firewall-cmd --permanent --list-services
```
Dovresti vedere un output simile.
```
dhcpv6-client http https mdns ssh
```
Ricarica il firewall.
```
$ sudo systemctl reload firewalld
```
Passaggio 2: installa Git

Il primo passo è installare Git.
```
$ sudo dnf install git
```
Verificare l'installazione controllando la versione di Git.
```
$ git --version
git version 2.31.1
```
Configura Git
Git può essere configurato con il comando git config. Imposta il tuo nome e indirizzo email per lavorare con Git.
```
$ git config --global user.name "Your Name"
$ git config --global user.email ""
```
È possibile verificare la configurazione utilizzando il seguente comando.
```
$ git config --list
user.name=Your Name
```
Passo 3 - Installa e configura PostgreSQL
Gitea supporta SQLite, MySQL/Mariadb, MSSQL e PostgreSQL. Per il nostro tutorial, useremo PostgreSQL.
Installa e inizializza PostgreSQL.
```
$ sudo dnf module enable postgresql:13
$ sudo dnf install postgresql-server postgresql-contrib
$ sudo postgresql-setup --initdb --unit postgresql
$ sudo systemctl enable --now postgresql
```
PostgreSQL utilizza lo schema di crittografia md5 per l'autenticazione della password per impostazione predefinita, che non è sicuro. Devi passare allo schema SCRAM-SHA-256. E se hai intenzione di connetterti a un database PostgreSQL remoto, devi configurarlo per ascoltare il tuo indirizzo IP. Entrambi possono essere modificati modificando il file /var/lib/pgsql/data/postgresql.conf. Aprilo per la modifica.
```
$ sudo nano /var/lib/pgsql/data/postgresql.conf
```
Modificare le seguenti variabili nel modo seguente.
```
listen_addresses = 'localhost, 201.0.110.0'
password_encryption = scram-sha-256
```
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Riavvia PostgreSQL.
```
$ sudo systemctl restart postgresql
```
Accedi alla shell PostgreSQL.
```
$ sudo -u postgres psql
```
Crea un nuovo utente e database SQL per Gitea. Scegli una password complessa per l'utente del database.
```
postgres-# CREATE ROLE gitea WITH LOGIN PASSWORD 'yourpassword';
postgres-# CREATE DATABASE giteadb WITH OWNER gitea TEMPLATE template0 ENCODING UTF8 LC_COLLATE 'en_US.UTF-8' LC_CTYPE 'en_US.UTF-8';
```
Sostituire il nome utente, il nome del database e la password come appropriato.
Esci dalla shell digitando \q.
Consenti all'utente del database di accedere al database creato sopra aggiungendo la seguente regola di autenticazione a /var/lib/pgsql/data/pg_hba.conf.
Se il database è locale, aggiungi questa riga.
```
local    giteadb    gitea    scram-sha-256
```
Per un database remoto, utilizzare invece il seguente codice.
```
host    giteadb    gitea    192.0.2.10/32    scram-sha-256
```
Dovrai anche modificare le seguenti righe aggiungendo la sostituzione di ident con scram-sha-256.
```
# IPv4 local connections:
host    all             all             127.0.0.1/32            ident
# IPv6 local connections:
host    all             all             ::1/128                 ident
```
Dovrebbero assomigliare a quanto segue.
```
# IPv4 local connections:
host    all             all             127.0.0.1/32            scram-sha-256
# IPv6 local connections:
host    all             all             ::1/128                 scram-sha-256
```
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Riavvia PostgreSQL.
```
$ sudo systemctl restart postgresql
```
Sarà inoltre necessario aggiungere la seguente regola nel firewall se si desidera abilitare le connessioni remote.
```
$ sudo firewall-cmd --permanent--add-service=postgresql
$ sudo firewall-cmd --reload
```
Passaggio 4: crea un utente Git
Crea un nuovo utente di sistema per eseguire l'applicazione Gitea.
```
$ sudo useradd \
   --system \
   --shell /bin/bash \
   --comment 'Git Version Control' \
   --create-home \
   --home /home/git \
   git
```
Questo comando crea un nuovo utente e gruppo denominato git e imposta la directory home su /home/git.
Passo 5 - Installa Gitea
Apri la pagina dei download di Gitea e controlla il numero di versione dell'ultimo binario disponibile. Al momento della stesura di questo tutorial, l'ultima versione è la 1.14.3. Se esiste una versione più recente, modificala nella variabile VERSION nel comando seguente.
Usa l'utility wget per prendere l'ultimo binario di Gitea.
```
$ GITEAVERSION=1.14.3
$ wget -O gitea https://dl.gitea.io/gitea/${GITEAVERSION}/gitea-${GITEAVERSION}-linux-amd64
```
Sposta il binario scaricato nella directory /usr/local/bin.
```
$ sudo mv gitea /usr/local/bin
```
Rendi eseguibile il file binario.
```
$ sudo chmod +x /usr/local/bin/gitea
```
Esegui i seguenti comandi per creare directory e impostare le autorizzazioni necessarie affinché Gitea funzioni correttamente.
```
$ sudo mkdir -p /var/lib/gitea/{custom,data,log}
$ sudo chown -R git:git /var/lib/gitea/
$ sudo chmod -R 750 /var/lib/gitea/
$ sudo mkdir /etc/gitea
$ sudo chown root:git /etc/gitea
$ sudo chmod 770 /etc/gitea
```
L'autorizzazione per la directory /etc/gitea è impostata su 770 affinché la procedura guidata di installazione crei il file di configurazione. Una volta completata l'installazione, imposteremo permessi più restrittivi.
Crea un file di servizio Systemd
Eseguiremo Gitea come servizio systemd. Per questo, crea un nuovo file di voci systemd per Gitea.
```
$ sudo nano /etc/systemd/system/gitea.service
```
Incolla il seguente codice al suo interno.
```
[Unit]
Description=Gitea
After=syslog.target
After=network.target
After=postgresql.service

[Service]
RestartSec=2s
Type=simple
User=git
Group=git
WorkingDirectory=/var/lib/gitea/
ExecStart=/usr/local/bin/gitea web -c /etc/gitea/app.ini
Restart=always
Environment=USER=git HOME=/home/git GITEA_WORK_DIR=/var/lib/gitea

[Install]
WantedBy=multi-user.target
```
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Per riferimento, puoi dare un'occhiata al file systemd di esempio disponibile dal repository Gitea.
Ricarica il demone systemd per abilitare il file che abbiamo appena creato.
```
$ sudo systemctl daemon-reload
```
Abilita e avvia il servizio Gitea.
```
$ sudo systemctl enable --now gitea
```
Verificare che Gitea sia in esecuzione.
```
$ sudo systemctl status gitea
  gitea.service - Gitea
     Loaded: loaded (/etc/systemd/system/gitea.service; enabled; vendor preset: disabled)
     Active: active (running) since Tue 2021-07-04 20:33:38 EDT; 1 day 8h ago
   Main PID: 46404 (gitea)
      Tasks: 7 (limit: 2328)
     Memory: 115.5M
        CPU: 9min 12.061s
     CGroup: /system.slice/gitea.service
             ---46404 /usr/local/bin/gitea web -c /etc/gitea/app.ini
...
```
Passo 6 - Configura Gitea
Gitea, per impostazione predefinita, è in ascolto sulla porta 3000. Puoi utilizzare una porta diversa o attenersi alla porta predefinita. Pertanto, dobbiamo aprire anche la porta 3000.
```
$ sudo firewall-cmd --permanent --add-port=3000/tcp
$ sudo firewall-cmd --reload
```
Apri il browser e digita https://YOURIPADDRESS:3000 e verrai accolto con il programma di installazione di Gitea. Utilizzare i seguenti valori per configurare.
Impostazioni database
- Tipo di database: scegli PostgreSQL dal menu a discesa
- Host: 127.0.0.1:5432
- Nome utente: gitea
- Password: la tuapassword
- Nome database: gitea
impostazioni generali
- Titolo del sito: inserisci il nome della tua organizzazione
- Percorso radice repository: lasciare il percorso predefinito
- Git LFS Root Path: lasciare il percorso predefinito
- Esegui come nome utente: git
- Dominio server SSH: inserisci il tuo indirizzo IP
- Porta di ascolto HTTP: 3000 (Puoi cambiare la porta qui, ma dovrai accedervi tramite il firewall.)
- URL Base Gitea: http://YOURIPADDRESS:3000
- Percorso registro: lasciare l'impostazione predefinita
È possibile configurare le impostazioni di posta elettronica e server a questo punto oppure è possibile modificarle in un secondo momento. Dovresti, tuttavia, compilare le impostazioni dell'account amministratore.
Per avviare l'installazione, fare clic sul pulsante Installa Gitea*. Una volta completato, verrai automaticamente loggato e reindirizzato alla dashboard dell'account.
L'installazione creerà il file di configurazione di Gitea. Cambia la sua autorizzazione in sola lettura.
```
$ sudo chmod 750 /etc/gitea
$ sudo chmod 640 /etc/gitea/app.ini
```
Questo è tutto. Gitea è ora installato sul tuo server.
Passaggio 7: installare SSL utilizzando Lets Encrypt
Per installare un certificato SSL utilizzando Lets Encrypt, è necessario scaricare lo strumento Certbot utilizzando il programma di installazione del pacchetto Snapd incluso in Ubuntu 20.04.
Eseguire i seguenti comandi per installare Certbot.
```
$ sudo dnf install certbot
```
Genera il certificato SSL.
```
$ sudo certbot certonly --standalone --preferred-challenges http -d example.com
```
Il comando precedente scaricherà un certificato nella directory /etc/letsencrypt/live/example.com sul tuo server.
Crea una directory webroot di verifica per il rinnovo automatico di Lets Encrypt.
```
$ sudo mkdir -p /var/lib/letsencrypt
```
Crea un Cron Job per rinnovare l'SSL. Verrà eseguito ogni giorno per controllare il certificato e rinnovarlo se necessario. Per questo, per prima cosa, crea il file /etc/cron.daily/certbot-renew e aprilo per modificarlo.
```
$ sudo nano /etc/cron.daily/certbot-renew
```
Incolla il seguente codice.
```
#!/bin/sh
certbot renew --cert-name example.com --webroot -w /var/lib/letsencrypt/ --post-hook "systemctl reload nginx"
```
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Modificare le autorizzazioni sul file dell'attività per renderlo eseguibile.
```
$ sudo chmod +x /etc/cron.daily/certbot-renew
```
Passaggio 8: installa e configura Nginx
Il prossimo passo è installare il server Nginx.
```
$ sudo dnf install nginx
```
Crea il file di configurazione Nginx per Gitea.
```
$ sudo nano /etc/nginx/conf.d/gitea.conf
```
Incolla il seguente codice al suo interno.
```
server {
        listen 80;
    
        location ~ /\.well-known/acme-challenge {
                root /var/lib/letsencrypt/;
        }
    
        server_name yourdomain.com;
        return 301 https://$server_name$request_uri;
}
server {
        listen 443 ssl http2;
        server_name your_domain;
    
        client_max_body_size 50m;
    
        ssl_session_timeout 1d;
        ssl_session_cache shared:MozSSL:10m;  # about 40000 sessions
        ssl_session_tickets off;
        ssl_protocols TLSv1.2 TLSv1.3;
        ssl_ciphers "ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20- POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384:!aNULL:!eNULL:!EXPORT:!DES:!MD5:!PSK:!RC4";
        ssl_prefer_server_ciphers off;
        ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
        ssl_stapling on;
        ssl_stapling_verify on;

        ssl_certificate /etc/letsencrypt/live/yourdomain.com/fullchain.pem;
        ssl_certificate_key /etc/letsencrypt/live/yourdomain.com/privkey.pem;
        ssl_trusted_certificate /etc/letsencrypt/live/yourdomain.com/chain.pem;
    
        proxy_read_timeout 720s;
        proxy_connect_timeout 720s;
        proxy_send_timeout 720s;
        
        proxy_set_header X-Forwarded-Host $host;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Real-IP $remote_addr;
    
        location / {
                proxy_redirect off;
                proxy_pass http://127.0.0.1:3000;
     	}
        access_log /var/log/nginx/gitea.access.log;
        error_log /var/log/nginx/gitea.error.log;
}
```
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Verificare se il file di configurazione funziona correttamente.
```
$ sudo nginx -t
```
Riavvia il server Nginx.
```
$ sudo systemctl restart nginx
```
Quindi, modifica il dominio Gitea e l'URL principale. Per farlo, apri il file di configurazione /etc/gitea/app.ini.
```
$ sudo nano /etc/gitea/app.ini
```
Modificare i seguenti valori.
```
[server]
SSH_DOMAIN       = git.example.com
DOMAIN           = git.example.com
ROOT_URL         = https://git.example.com/
```
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Riavvia il servizio Gitea.
```
$ sudo systemctl restart gitea
```
Passaggio 9: configurazione delle notifiche e-mail
Se desideri ricevere notifiche e-mail, puoi abilitarle tramite Sendmail o tramite un servizio di transazione e-mail di terze parti come Amazon SES, Postmark, Mailgun o Sendgrid.
Per abilitare le notifiche, apri il file di configurazione /etc/gitea/app.ini.
```
$ sudo nano /etc/gitea/app.ini
```
Modifica la seguente sezione nel file e aggiungi il seguente codice.
```
[mailer]
ENABLED = true
FROM           = 
MAILER_TYPE    = smtp
HOST           = mail.mydomain.com:587
IS_TLS_ENABLED = true
USER           = 
PASSWD         = `password`
```
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Riavvia il servizio Gitea.
```
$ sudo systemctl restart gitea
```
Passaggio 10: aggiornamento di Gitea
L'aggiornamento di Gitea comporta il download e la sostituzione del file binario di Gitea.
Innanzitutto, interrompi il servizio Gitea.
```
$ sudo systemctl stop gitea
```
Scarica e installa il binario di Gitea.
```
$ GITEAVERSION=LATESTVERSION
$ wget -O gitea https://dl.gitea.io/gitea/${GITEAVERSION}/gitea-${GITEAVERSION}-linux-amd64
$ sudo mv gitea /usr/local/bin
$ sudo chmod +x /usr/local/bin/gitea
```
Riavvia il servizio Gitea.
```
$ sudo systemctl start gitea
```
Passaggio 11: come utilizzare SSH
Per utilizzare SSH, dobbiamo aggiungere la nostra chiave SSH a Gitea. Se non ne hai uno, puoi crearne uno usando il seguente comando sul tuo sistema locale.
```
$ ssh-keygen -N "yourpassphrase" -t ed25519 -C "gitea_key"
```
Questo creerà una chiave chiamata id_ed25519 nella directory ~/.ssh. Per aggiungere questa chiave, copia il contenuto del file ~/.ssh/id_ed25519.pub negli appunti. Quindi aggiungi questa chiave alla pagina delle impostazioni di Gitea nella scheda Chiavi SSH/GPG. Fare clic sul pulsante Aggiungi chiave e assegnare un nome alla chiave e incollarlo nella casella.
Se hai un elenco di utenti consentiti nel file di configurazione di sshd, devi aggiungere git.
Apri il file di configurazione SSHD.
```
$ sudo nano /etc/ssh/sshd_config
```
Cerca una linea che dovrebbe assomigliare alla seguente.
```
AllowUsers myuser myotheruser git
```
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Riavvia il servizio SSHD.
```
$ sudo systemctl restart ssh
```
Devi aggiungere la passphrase per la chiave che abbiamo creato allo strumento ssh-agent sul tuo sistema locale in modo che non ti venga chiesta ripetutamente. Esegui i seguenti comandi per farlo.
```
$ eval $(ssh-agent)
Agent pid 46436
$ ssh-add ~/.ssh/id_ed25519
```
Puoi clonare il tuo repository per testare la connessione SSH.
```
$ git clone ssh:///username/repo.git
Cloning into 'repo'...
The authenticity of host 'example.com (201.110.80.160)' can't be established.
ECDSA key fingerprint is SHA256:Kx9l19zpGhHfbb2wHtmWeC7/WWv8e5/T3Tcws2qwVEw.
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
Warning: Permanently added 'example.com,201.110.80.160' (ECDSA) to the list of known hosts.
remote: Enumerating objects: 5, done.
remote: Counting objects: 100% (5/5), done.
remote: Compressing objects: 100% (4/4), done.
remote: Total 5 (delta 0), reused 0 (delta 0)
Receiving objects: 100% (5/5), 4.77 KiB | 977.00 KiB/s, done.
```
Conclusione
Questo conclude il tutorial sull'installazione e la configurazione del servizio di hosting del codice Gitea su Fedora 34. Se hai domande, pubblicale nei commenti qui sotto.

Come installare Gitea Code Hosting Service su Fedora 34

Su questa pagina

Prerequisiti

Passaggio 1: configurare il firewall

Passaggio 2: installa Git

Configura Git

Passo 3 - Installa e configura PostgreSQL

Passaggio 4: crea un utente Git

Passo 5 - Installa Gitea

Crea un file di servizio Systemd

Passo 6 - Configura Gitea

Passaggio 7: installare SSL utilizzando Lets Encrypt

Passaggio 8: installa e configura Nginx

Passaggio 9: configurazione delle notifiche e-mail

Passaggio 10: aggiornamento di Gitea

Passaggio 11: come utilizzare SSH

Conclusione