Docker è una popolare piattaforma open-source per lo sviluppo, la distribuzione e l’esecuzione di applicazioni. Incapsula le applicazioni e le loro dipendenze in container per promuovere la coerenza tra i diversi ambienti. Questa coerenza aiuta a prevenire i problemi legati ai conflitti di dipendenza e alle discrepanze dovute ai soliti “sulla mia macchina funziona”.
Con Docker, è possibile definire le dipendenze e le estensioni necessarie utilizzando i Dockerfile. Questo significa che le applicazioni hanno tutte le librerie e gli strumenti necessari in un ambiente riproducibile e isolato.
L’Hosting di Applicazioni di Kinsta offre un supporto dinamico per i Dockerfile personalizzati, che permette di avere un maggiore controllo sull’ambiente della propria applicazione. Con un Dockerfile si possono utilizzare quasi tutti i linguaggi: non si è limitati ai linguaggi supportati da Nixpacks o da Buildpacks.
Questo articolo spiega come installare e utilizzare le dipendenze e le estensioni PHP in Docker.
Perché usare Docker per installare le dipendenze?
L’uso di Docker per installare le dipendenze presenta diversi vantaggi:
- Coerenza dell’ambiente: Docker permette di impacchettare l’applicazione, le sue dipendenze e le sue configurazioni in un contenitore. Questo approccio garantisce che l’ambiente in cui viene eseguita l’applicazione rimanga coerente tra le diverse configurazioni e sistemi, compresi gli ambienti di sviluppo, di test e di produzione.
- Facilità di configurazione e risoluzione delle dipendenze: Docker permette di configurare l’ambiente dell’applicazione su qualsiasi macchina che la supporti, specificando tutte le dipendenze e le configurazioni necessarie. In questo modo si evitano i problemi di compatibilità e la seccatura di installare manualmente le dipendenze.
- Controllo della versione e isolamento: i container Docker incapsulano tutte le dipendenze, comprese le loro versioni specifiche all’interno del contenitore. Ciò significa che si può controllare la versione dell’applicazione e delle sue dipendenze, favorendo la riproducibilità ed eliminando i conflitti tra le diverse versioni delle dipendenze.
Inoltre, i container Docker garantiscono l’isolamento e aiutano a eliminare i conflitti tra le dipendenze di applicazioni diverse in esecuzione sullo stesso sistema.
Configurare un’applicazione su Kinsta
La configurazione di un’applicazione su Kinsta è semplice. Infatti, basta andare su MyKinsta e seguire il processo per creare un account. Una volta creato, sarà possibile accedere a una potente dashboard di hosting e a una serie di funzioni progettate per ottimizzare le prestazioni e la sicurezza.
L’Hosting di Applicazioni di Kinsta supporta una serie di linguaggi di programmazione, tra cui PHP, Python, Node.js e Ruby. Questo ampio supporto di linguaggi garantisce la compatibilità con diverse applicazioni e permette di scegliere il linguaggio più adatto alle esigenze del proprio progetto.
Ad esempio, se state sviluppando un’applicazione web dinamica con PHP, l’ambiente di hosting ottimizzato di Kinsta garantisce prestazioni elevate e affidabilità ai vostri progetti basati su PHP. Oppure, se state realizzando un’API RESTful con Node.js o un’applicazione web data-driven con Python, Kinsta fornisce l’infrastruttura e il supporto necessari per la vostra applicazione.
Per sperimentare come distribuire un’applicazione utilizzando un Dockerfile su Kinsta, useremo questa applicazione, un sistema di autenticazione di base basato su PHP che utilizza MariaDB per memorizzare i dati. Questa applicazione sfrutta anche alcuni pacchetti di composer, tra cui respect/validation per la validazione degli input e ircmaxell/password-compat per l’hashing delle password.
Preparare l’ambiente Docker
Un Dockerfile è un file di testo contenente tutti i comandi, disposti nell’ordine necessario, di cui avremo bisogno per costruire l’immagine richiesta. Un Dockerfile di base per un’applicazione PHP potrebbe essere il seguente:
FROM php:8.3-cli
COPY . /usr/src/myapp
WORKDIR /usr/src/myapp
CMD [ "php", "./your-script.php" ]Questo Dockerfile crea un ambiente container per eseguire uno script PHP da un’interfaccia a riga di comando (CLI). Inizia utilizzando l’immagine ufficiale di PHP con la variante CLI, assicurandosi che solo il runtime PHP sia incluso nel contenitore.
In seguito, copia il contenuto della directory locale – che contiene il Dockerfile – nella directory /usr/src/myapp all’interno del container. Dopo aver impostato la directory di lavoro su /usr/src/myapp, specifica lo script PHP da eseguire, your-script.php, utilizzando il comando php.
L’immagine contiene molte estensioni PHP precompilate. Quindi, iniziamo a verificare se l’estensione di cui abbiamo bisogno è installata eseguendo il comando php -m.
Se l’estensione richiesta non è disponibile nell’immagine di base, Docker fornisce i seguenti script di aiuto per supportarci a installare più facilmente le estensioni aggiuntive:
docker-php-ext-configuredocker-php-ext-installdocker-php-ext-enable
Ad esempio, l’applicazione demo di questo tutorial utilizza l’estensione MySQLi per interagire con il database MariaDB. Questa estensione non è compilata di default nell’immagine, quindi installiamola usando il seguente comando nel Dockerfile:
RUN docker-php-ext-install mysqliPer scrivere un Dockerfile per l’applicazione demo, creiamo un nuovo file chiamato Dockerfile nella cartella principale del progetto. Incolliamo il seguente codice nel file:
FROM php:8.3-apache
# Install MySQL client, server, and other dependencies
RUN apt-get update && \
apt-get install -y \
default-mysql-client \
default-mysql-server \
git \
&& apt-get clean \
&& rm -rf /var/lib/apt/lists/*
# Install mysqli PHP extension for MySQL support
RUN docker-php-ext-install mysqliQuesto codice specifica l’immagine ufficiale di PHP – in particolare la versione 8.3 – con Apache installato come immagine di base per il container. Questa immagine fornisce un ambiente preconfigurato per l’esecuzione di applicazioni PHP con Apache come server web.
Poi installa le dipendenze aggiuntive necessarie all’applicazione demo, tra cui default-mysql-client e default-mysql-server, che creano e interagiscono con il database MariaDB.
Infine, lo snippet qui sopra installa l’estensione PHP mysqli utilizzando docker-php-ext-install, che permette all’applicazione demo di stabilire una connessione ed eseguire operazioni sul database MariaDB.
Gestire le dipendenze con Docker
La gestione delle dipendenze PHP con Docker prevede l’utilizzo di Composer, un popolare gestore di dipendenze per PHP. Installando Composer in un container Docker, è possibile semplificare il processo di installazione, aggiornamento e gestione delle dipendenze PHP, facilitando la coerenza e la riproducibilità in ambienti diversi.
Seguiamo i passi qui sotto per utilizzare Composer per la gestione delle dipendenze all’interno dell’applicazione demo. Aggiungiamo il codice di ogni passaggio al Dockerfile.
- Installiamo Composer nell’immagine Docker utilizzando il comando seguente:
# Install Composer COPY --from=composer/composer:latest-bin /composer /usr/bin/composerQuesto comando copia un file binario pre-costruito di Composer dal repository di Docker Hub nella nostra immagine.
--from=composer/composer:latest-binspecifica l’immagine sorgente da cui copiare i file.Il percorso
/composerdell’immagine sorgente contiene i file da copiare, mentre il percorso/usr/bin/composerdell’immagine Docker è la destinazione di questi file. - Quindi, impostiamo la directory di lavoro eseguendo il seguente comando:
# Set working directory WORKDIR /var/www/html - Copiamo i file composer.json e composer.lock nell’immagine.
# Copy composer.json and composer.lock COPY composer.json composer.lock ./ - Installiamo le dipendenze di Composer elencate in composer.json.
# Install Composer dependencies RUN composer install --no-dev --optimize-autoloader--no-devindica a Composer di saltare le dipendenze specifiche dello sviluppo.--optimize-autoloaderindica a Composer di ottimizzare l’autoloader per ottenere prestazioni migliori.
Possiamo aggiornare e gestire le dipendenze nel tempo modificando il file composer.json secondo le necessità, aggiungendo nuove dipendenze, aggiornando i vincoli di versione e rimuovendo le dipendenze non più necessarie.
Dopo aver apportato le modifiche necessarie, eseguiamo composer install o composer update all’interno del container Docker per installare o aggiornare le dipendenze di conseguenza.
Applicare le configurazioni finali
Prima che l’applicazione funzioni con Docker, dobbiamo creare il database e l’utente del database, impostare le variabili d’ambiente e copiare i file del progetto nell’immagine Docker.
A tal fine, seguiamo questi passaggi e copiamo ogni frammento di codice nel nostro Dockerfile.
- Impostiamo le variabili d’ambiente che l’applicazione PHP utilizzerà per connettersi al database MariaDB.
DB_USER,DB_PASSWORDeDB_NAMEpossono essere sostituiti con le nostre credenziali preferite.# Set environment variables ENV DB_HOST=localhost \ DB_USER=kinsta_user \ DB_PASSWORD=your_password_here \ DB_NAME=kinsta_docker_auth \ # Path to the Unix socket file used for connecting to the MariaDB server. DB_SOCKET=/var/run/mysqld/mysqld.sock - Copiamo i file dell’applicazione PHP nell’immagine Docker:
# Copy PHP application files into the image COPY . . - Copiamo lo script di avvio nell’immagine:
# Copy the startup script COPY scripts/start.sh /usr/local/bin/start.shQuesto script viene eseguito all’avvio del container ed è responsabile dell’avvio del server di database, della creazione di un database, di una tabella e di un utente e dell’avvio del server Apache. Creeremo questo script in seguito.
- Rendiamo lo script eseguibile utilizzando il comando
chmodil comando# Make the script executable RUN chmod +x /usr/local/bin/start.sh - Infine, eseguiamo lo script utilizzando il comando:
# Execute the startup script CMD ["/usr/local/bin/start.sh"]
Ora che il Dockerfile è completo, creiamo lo script di avvio di cui abbiamo parlato in precedenza.
Creiamo un nuovo file chiamato scripts/start.sh nella cartella principale del progetto e aggiungiamo il seguente codice. Assicuriamoci di utilizzare le credenziali del database che abbiamo definito nel Dockerfile.
#!/bin/bash
# Start MariaDB server
service mariadb start
# Wait for MariaDB to be fully initialized (retry up to 30 times, waiting 1 second between each attempt)
attempt=0
while [ $attempt -lt 30 ]; do
if mysqladmin ping &>/dev/null; then
echo "MariaDB is up and running."
break
else
echo "MariaDB is not yet available. Retrying..."
attempt=$((attempt+1))
sleep 1
Fi
done
# If MariaDB failed to start within the specified attempts, exit with an error
if [ $attempt -eq 30 ]; then
echo "Error: MariaDB failed to start within the specified time."
exit 1
fi
# Set the database name, username, and password
dbname="kinsta_docker_auth"
dbuser="kinsta_user"
dbpassword="your_password_here"
# Create the database if it does not exist
mysql -u root -e "CREATE DATABASE IF NOT EXISTS $dbname;"
# Create a database user and assign privileges to the database
mysql -u root -e "CREATE USER '$dbuser'@'localhost' IDENTIFIED BY '$dbpassword';"
mysql -u root -e "GRANT ALL PRIVILEGES ON $dbname.* TO '$dbuser'@'localhost';"
mysql -u root -e "FLUSH PRIVILEGES;"
# Create users table if it does not exist
mysql -u root -e "USE $dbname; CREATE TABLE IF NOT EXISTS users (
id INT AUTO_INCREMENT PRIMARY KEY,
username VARCHAR(20) UNIQUE NOT NULL,
password_hash VARCHAR(255) NOT NULL
);"
# Start Apache server
apache2ctl -D FOREGROUNDQuesto script Bash avvia il server MariaDB. Poi, quando il server è completamente inizializzato, crea un database, un utente con i privilegi appropriati e una tabella all’interno del database. Infine, avvia il server Apache.
Distribuire su Kinsta
Prima di distribuire la nostra applicazione su Kinsta, dobbiamo configurare alcune configurazioni per il server Apache. Il servizio di Hosting di Applicazioni di Kinsta ha le porte 80 e 443 aperte, ma è consigliabile utilizzare la porta 8080 se l’applicazione espone qualche porta.
Per impostazione predefinita, il server Apache ascolta le connessioni sulla porta 80, quindi dovremo configurarlo per ascoltare le connessioni sulla porta 8080. Per farlo, seguiamo questi passaggi:
- Creiamo una cartella chiamata apache-conf nella cartella principale del progetto.
- Nella cartella appena creata, creiamo un file chiamato apache-config.conf. Aggiungiamo il codice seguente per configurare Apache in modo che ascolti le connessioni sulla porta 8080:
<VirtualHost *:8080> ServerAdmin webmaster@localhost DocumentRoot /var/www/html ErrorLog ${APACHE_LOG_DIR}/error.log CustomLog ${APACHE_LOG_DIR}/access.log combined </VirtualHost> - Nella cartella apache-conf, creiamo un nuovo file chiamato apache-ports.conf e aggiungiamo il codice seguente.
# Change the Listen directive to listen on port 8080 Listen 8080 # Keep the existing configuration for port 443 <IfModule ssl_module> Listen 443 </IfModule> <IfModule mod_gnutls.c> Listen 443 </IfModule>La direttiva
Listen 8080indica ad Apache di ascoltare le connessioni in entrata sulla porta 8080. - Ora dobbiamo modificare il Dockerfile per applicare questa configurazione al server Apache. Nel Dockerfile, aggiungiamo questi comandi subito dopo il comando per impostare la directory di lavoro (
WORKDIR /var/www/html). Questi sono responsabili della copia dei file di configurazione personalizzati nelle directory appropriate.# Set up Apache virtual host COPY apache-conf/apache-config.conf /etc/apache2/sites-available/000-default.conf # Set up Apache ports COPY apache-conf/apache-ports.conf /etc/apache2/ports.conf - Infine, creiamo un file .dockerignore nella cartella principale del progetto. Questo file contiene un elenco di cartelle e file che non devono essere copiati nell’immagine Docker. Aggiungiamo
vendorper escludere la cartella vendor.
Una volta completate tutte le configurazioni, possiamo effettuare il deploy su Kinsta. Carichiamo i file del progetto sul nostro provider Git preferito (Bitbucket, GitHub o GitLab), quindi seguiamo i passaggi qui in basso.
- Nella dashboard MyKinsta, selezioniamo Applicazioni nella barra laterale e clicchiamo sul pulsante Aggiungi applicazione.
- Nella pagina Aggiungi applicazione, selezioniamo il repository Git e il branch, forniamo il nome dell’applicazione, scegliamo la posizione del data center e clicchiamo su Continua.
- Nella pagina dell’ambiente di build, selezioniamo Usa Dockerfile per impostare l’immagine del container. Forniamo “Dockerfile” come percorso del Dockerfile e un punto (“.”) come contesto. Clicchiamo su Continua.
Sezione Ambiente di build del modulo Aggiungi applicazione. - Lasciamo tutto nella pagina Imposta i processi e clicchiamo su Continua. Nota: il database perderà i dati quando riavviamo o distribuiamo nuovamente l’applicazione. Per risolvere questo problema, l’archiviazione persistente di Kinsta può essere applicata in questa pagina. Questa guida non analizza l’impostazione dell’archiviazione persistente.
- Confermiamo i dettagli del pagamento nella pagina di riepilogo e clicchiamo su Distribuisci ora.
- Una volta completata la distribuzione, apriamo il dominio dell’applicazione per visualizzare il sito live.
Pagina di login sul sito live. Registriamo un account, accediamo con i nostri dati e verifichiamo che sia possibile accedere alla pagina protetta e che tutto funzioni come previsto.
La homepage dell’applicazione una volta effettuato l’accesso.
Monitorare e ottimizzare l’applicazione
Una volta che l’applicazione è attiva e funzionante su Kinsta, il monitoraggio e l’ottimizzazione delle sue prestazioni sono essenziali. Questo assicura che l’applicazione possa funzionare senza problemi e utilizzare le risorse in modo efficiente.
L’ottimizzazione delle prestazioni dell’applicazione è fondamentale per offrire un’esperienza utente veloce e reattiva.
Kinsta è sempre al lavoro per ottimizzare le prestazioni delle applicazioni. Offriamo strumenti di monitoraggio completi per aiutarvi a tenere traccia di varie metriche di performance, tra cui la larghezza di banda, il tempo totale di build, l’utilizzo della CPU, il consumo di memoria, il traffico di rete e i tempi di risposta. È possibile visualizzare tutte queste informazioni navigando nella sezione Statistiche dell’applicazione sulla dashboard di Kinsta.
Se riscontrate un problema o un comportamento inaspettato dell’applicazione, potete accedere alla sezione Log della dashboard di Kinsta. La panoramica dettagliata delle prestazioni e del comportamento dell’applicazione include i log degli errori e degli accessi.
Esaminando meticolosamente questi registri, è possibile ottenere informazioni preziose sulle cause del problema, come i messaggi di errore, le stack traces o i modelli di comportamento anomalo. Queste informazioni possono aiutarvi a diagnosticare la causa principale del problema e a intraprendere le azioni appropriate per risolverlo.
Inoltre, potrete sfruttare le tecniche di ottimizzazione delle prestazioni all’interno dell’ambiente Docker, come l’ottimizzazione delle immagini Docker e l’implementazione delle best practice per l’architettura delle applicazioni e l’ottimizzazione del codice.
Riepilogo
I container leggeri e portatili di Docker consentono di impacchettare e distribuire facilmente le applicazioni con tutte le dipendenze necessarie, indipendentemente dall’infrastruttura sottostante. Inserendo in un container un’applicazione e le sue dipendenze, si promuove la coerenza tra i diversi ambienti, si semplificano i processi di configurazione e si ottiene un migliore controllo delle versioni.
L’utilizzo di Docker con Kinsta migliora il processo di distribuzione della vostra applicazione. Il supporto di Dockerfile personalizzati e di un’ampia gamma di linguaggi di programmazione, tra cui PHP, garantisce compatibilità e flessibilità ai vostri progetti.
Grazie all’infrastruttura di Hosting di Applicazioni e alla tecnologia di containerizzazione di Docker, potete ottenere una distribuzione semplificata, scalabilità e affidabilità per le vostre applicazioni.
Avete già utilizzato Docker per i vostri progetti? Avete esperienze o suggerimenti su Docker? Condivideteli nei commenti qui sotto!
Lascia un commento