Cos'è Docker? Scopri come utilizzare i contenitori - Spiegazione con esempi

I container sono oggi uno strumento essenziale per lo sviluppo del software. L'esecuzione di applicazioni in qualsiasi ambiente diventa facile quando si sfruttano i container.

La tecnologia più popolare per l'esecuzione di container è Docker, che funziona su qualsiasi sistema operativo.

In questo post del blog imparerai a utilizzare Docker per i primi 3 casi d'uso più essenziali. Imparerai come:

• esegui un database in locale utilizzando Docker,
• esegui test automatizzati utilizzando un database ancorato
• esegui la tua applicazione in locale e in produzione utilizzando Docker.

Utilizzerai un'applicazione Java Spring Boot, ma tutti gli insegnamenti si applicano a ogni altro linguaggio di programmazione di tua scelta.

Per eseguire tutti gli esempi, devi:

• Installa Docker
• Installa Java

Esegui applicazioni isolate utilizzando Docker

Docker elimina le attività di configurazione ripetitive e banali e viene utilizzato durante tutto il ciclo di vita dello sviluppo per lo sviluppo di applicazioni veloce, facile e portatile, desktop e cloud. (Fonte:https://www.docker.com/use-cases/)

Il fulcro della superpotenza di Docker è sfruttare i cosiddetti cgroup per creare ambienti leggeri, isolati, portatili e performanti, che puoi avviare in pochi secondi.

Diamo un'occhiata a come puoi utilizzare Docker per essere più produttivo.

Contenitori di database

Usando Docker, puoi avviare molti tipi di database in pochi secondi. È facile e non inquina il tuo sistema locale con altri requisiti necessari per eseguire il database. Tutto viene confezionato con il contenitore Docker.

Eseguendo una ricerca su hub.docker.com, puoi trovare contenitori pronti per l'uso per molti database.

Usando la docker run comando, puoi avviare un container MySQL Docker.

docker run --rm -v "$PWD/data":/var/lib/mysql --name mysql -e MYSQL_ROOT_PASSWORD=admin-password -e MYSQL_DATABASE=my-database -p 3306:3306 mysql:8.0.28-debian

Questo comando utilizza le funzionalità avanzate per l'esecuzione di un contenitore Docker:

• -v "$PWD/data" mappa la tua directory locale ./data al contenitore Docker, che ti consente di avviare il contenitore Docker senza perdere i tuoi dati,
• -p 3306:3306 mappa la porta del container 3306 alla nostra macchina in modo che altre applicazioni possano utilizzarla,
• -e MYSQL_DATABASE=my-database imposta una variabile di ambiente per creare un nuovo database chiamato my-database automaticamente,
• -e MYSQL_ROOT_PASSWORD=admin-password imposta una variabile di ambiente per impostare la password dell'amministratore,
• --rm rimuove il contenitore quando è fermo.

Queste variabili di ambiente e altre ancora sono documentate nella pagina dell'immagine Docker.

Come utilizzare i contenitori di database per lo sviluppo

Utilizzerai uno stack tecnologico popolare per creare un'applicazione Web basata su Java e Spring Boot. Per concentrarti sulle parti Docker, puoi clonare una semplice applicazione demo dalla guida ufficiale all'accesso ai dati JPA con riposo.

# Download the sample application
git clone https://github.com/spring-guides/gs-accessing-data-rest.git

# Open the final application folder
cd complete

L'applicazione viene fornita con un database in memoria, che non è utile per la produzione perché non consente a più servizi di accedere e modificare un singolo database. Un database MySQL è più adatto per ridimensionare la tua applicazione a molte più letture e scritture.

Pertanto, aggiungi il driver MySQL al tuo pom.xml :

       <!-- Disable in memory database -->
       <!--
       <dependency>
           <groupId>com.h2database</groupId>
           <artifactId>h2</artifactId>
           <scope>runtime</scope>
       </dependency>
       -->
 
       <!-- MySQL driver -->
       <dependency>
           <groupId>mysql</groupId>
           <artifactId>mysql-connector-java</artifactId>
           <scope>runtime</scope>
       </dependency>

Ora devi aggiungere la configurazione per connetterti al tuo database aggiungendo un file di configurazione src/main/resources/application.properties .

# Database configuration
spring.datasource.url=jdbc:mysql://localhost:3306/my-database
spring.datasource.username=root
spring.datasource.password=admin-password
 
# Create table and database automatically
spring.jpa.hibernate.ddl-auto=update

Ora puoi avviare l'applicazione e chiamare gli endpoint esistenti:

# Get all people
curl http://localhost:8080/people

# Add a person
curl -i -H "Content-Type:application/json" -d '{"firstName": "Frodo", "lastName": "Baggins"}' http://localhost:8080/people

# Get all people again, which now returns the created person
curl http://localhost:8080/people

Hai utilizzato con successo la tua applicazione rudimentale, che scrive e legge i dati nel tuo database. L'uso del database MySQL Docker ti offre un database robusto in pochi secondi e puoi usarlo da qualsiasi applicazione.

Come utilizzare i contenitori di database per i test di integrazione

L'applicazione dispone già di test che prevedono un database in esecuzione. Tuttavia, poiché hai sostituito il tuo database in memoria con un vero database MySQL, i test non verranno eseguiti correttamente se interrompi il database.

# Stop database
docker rm -f mysql

# Run tests
./mvnw clean test

... skipped output ...
[ERROR] Tests run: 7, Failures: 0, Errors: 7, Skipped: 0
... skipped output ...

Per avviare e interrompere rapidamente i test sui contenitori, è disponibile uno strumento utile chiamato testcontainers. Lì troverai le librerie per molti linguaggi di programmazione, incluso Java.

Per prima cosa, devi aggiungere alcune dipendenze al tuo pom.xml :

       <!-- testcontainer -->
       <dependency>
           <groupId>org.testcontainers</groupId>
           <artifactId>testcontainers</artifactId>
           <version>1.16.3</version>
           <scope>test</scope>
       </dependency>
       <dependency>
           <groupId>org.testcontainers</groupId>
           <artifactId>mysql</artifactId>
           <version>1.16.3</version>
           <scope>test</scope>
       </dependency>
       <dependency>
           <groupId>org.testcontainers</groupId>
           <artifactId>junit-jupiter</artifactId>
           <version>1.16.3</version>
           <scope>test</scope>
       </dependency>

È necessario aggiornare i test per utilizzare i testcontainer, che avviano il database a ogni esecuzione di test. Aggiungi un'annotazione e un campo al test per utilizzarlo:

//added imports
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.DynamicPropertyRegistry;
import org.springframework.test.context.DynamicPropertySource;
import org.testcontainers.containers.MySQLContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;
 
@SpringBootTest
@AutoConfigureMockMvc
@Testcontainers // Annotation to enable testcontainers
public class AccessingDataRestApplicationTests {
 
   // Field to access the started database
   @Container
   private static MySQLContainer database = new MySQLContainer<>("mysql:5.7.34");
 
   //Set database configuration using the started database
   @DynamicPropertySource
   static void databaseProperties(DynamicPropertyRegistry registry) {
       registry.add("spring.datasource.url", database::getJdbcUrl);
       registry.add("spring.datasource.username", database::getUsername);
       registry.add("spring.datasource.password", database::getPassword);
   }

Per ogni esecuzione di test, il database viene avviato per te, il che ti consente di utilizzare un database effettivo quando esegui i test. Tutti i cablaggi, la configurazione, l'avvio e la pulizia sono tutti fatti per te.

Dockerizza la tua applicazione

Dockerizzare l'applicazione utilizzando semplici strumenti Docker è possibile ma non consigliato.

Puoi creare la tua applicazione, utilizzare un contenitore di base che contiene Java e copiare ed eseguire la tua applicazione. Ma ci sono molte insidie ​​e questo vale per ogni lingua e struttura. Quindi cerca sempre strumenti che ti semplifichino la vita.

In questo esempio, utilizzerai contenitori Jib e distroless per creare facilmente un contenitore Docker. L'utilizzo di entrambi in combinazione offre un contenitore minimo, sicuro e riproducibile, che funziona allo stesso modo a livello locale e in produzione.

Per utilizzare Jib, devi aggiungerlo come plug-in Maven aggiungendolo al tuo pom.xml :

<build>
       <plugins>
           <plugin>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-maven-plugin</artifactId>
           </plugin>
 
        <!-- Jib plugin -->
           <plugin>
               <groupId>com.google.cloud.tools</groupId>
               <artifactId>jib-maven-plugin</artifactId>
               <version>3.2.1</version>
               <configuration>
                   <from>
                       <image>gcr.io/distroless/java17:nonroot</image>
                   </from>
                   <to>
                       <image>my-docker-image</image>
                   </to>
               </configuration>
           </plugin>
       </plugins>
   </build>

Ora puoi creare l'immagine ed eseguire l'applicazione:

# build the docker container
./mvnw compile jib:dockerBuild

# find your build image
docker images

# start the database
docker run --rm -v "$PWD/data":/var/lib/mysql --name mysql -e MYSQL_ROOT_PASSWORD=admin-password -e MYSQL_DATABASE=my-database -p 3306:3306 mysql:8.0.28-debian


# start the docker container which contains your application
docker run --net=host my-docker-image

… skipped output…
2022-04-15 17:43:51.509  INFO 1 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2022-04-15 17:43:51.521  INFO 1 --- [           main] c.e.a.AccessingDataRestApplication       : Started AccessingDataRestApplication in 6.146 seconds (JVM running for 6.568)

L'applicazione viene avviata con l'host in modalità rete --net=host , che semplifica la connessione al database che hai avviato. In alternativa, puoi creare una docker network e avvia entrambi nella stessa rete.

Puoi eseguire il push del tuo container in un registro container e farvi riferimento da qualsiasi strumento di orchestrazione container per eseguire l'applicazione in produzione.