Co je Docker? Naučte se používat kontejnery – vysvětleno s příklady

Kontejnery jsou dnes nezbytným nástrojem pro vývoj softwaru. Spouštění aplikací v jakémkoli prostředí se stane snadným, když využijete kontejnery.

Nejoblíbenější technologií pro spouštění kontejnerů je Docker, který běží na jakémkoli operačním systému.

V tomto blogovém příspěvku se naučíte používat Docker pro 3 nejdůležitější případy použití. Naučíte se, jak:

• místně spustit databázi pomocí Docker,
• spouštět automatizované testy pomocí dockerizované databáze,
• spusťte svou aplikaci lokálně a v produkci pomocí Dockeru.

Budete používat aplikaci Java Spring Boot, ale všechny poznatky platí pro každý jiný programovací jazyk podle vašeho výběru.

Chcete-li spustit všechny příklady, musíte:

• Nainstalujte Docker
• Nainstalujte Javu

Spouštění izolovaných aplikací pomocí Dockeru

Docker odstraňuje opakující se všední konfigurační úlohy a používá se po celý životní cyklus vývoje pro rychlý, snadný a přenosný vývoj aplikací – desktopů i cloudů. (Zdroj:https://www.docker.com/use-cases/)

Jádrem superschopnosti Dockeru je využití takzvaných cgroups k vytvoření lehkých, izolovaných, přenosných a výkonných prostředí, které můžete spustit během několika sekund.

Podívejme se, jak můžete pomocí Dockeru být produktivnější.

Databázové kontejnery

Pomocí Dockeru můžete spustit mnoho typů databází během několika sekund. Je to snadné a neznečišťuje to váš místní systém dalšími požadavky, které potřebujete ke spuštění databáze. Vše je zabaleno s kontejnerem Docker.

Prohledáním hub.docker.com můžete najít kontejnery připravené k použití pro mnoho databází.

Pomocí docker run můžete spustit kontejner 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

Tento příkaz využívá pokročilé funkce spouštění kontejneru Docker:

• -v "$PWD/data" mapuje váš místní adresář ./data do kontejneru docker, což vám umožní spustit kontejner Docker bez ztráty dat,
• -p 3306:3306 mapuje port kontejneru 3306 k našemu počítači, aby jej mohly používat jiné aplikace,
• -e MYSQL_DATABASE=my-database nastavuje proměnnou prostředí pro vytvoření nové databáze s názvem my-database automaticky,
• -e MYSQL_ROOT_PASSWORD=admin-password nastavuje proměnnou prostředí pro nastavení hesla správce,
• --rm při zastavení odstraní nádobu.

Tyto proměnné prostředí a další jsou zdokumentovány na stránce obrázku Docker.

Jak používat databázové kontejnery pro vývoj

K vytvoření webové aplikace založené na Javě a Spring Boot použijete oblíbený technologický stack. Chcete-li se zaměřit na části Dockeru, můžete naklonovat jednoduchou ukázkovou aplikaci z oficiálního průvodce Accessing JPA Data With Rest Guide.

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

# Open the final application folder
cd complete

Aplikace je dodávána s databází v paměti, která není pro produkci cenná, protože neumožňuje více službám přístup a mutaci jedné databáze. Databáze MySQL je vhodnější pro škálování vaší aplikace na mnohem více čtení a zápisů.

Přidejte proto ovladač MySQL do 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>

Nyní musíte přidat konfiguraci pro připojení k databázi přidáním konfiguračního souboru 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

Nyní můžete spustit aplikaci a volat existující koncové body:

# 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

Úspěšně jste použili svou základní aplikaci, která zapisuje a čte data ve vaší databázi. Použití databáze MySQL Docker vám poskytne robustní databázi během několika sekund a můžete ji používat z jakékoli aplikace.

Jak používat databázové kontejnery pro integrační testy

Aplikace již má testy, které očekávají běžící databázi. Ale protože jste svou databázi v paměti nahradili skutečnou databází MySQL, testy se nespustí úspěšně, pokud databázi zastavíte.

# 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 ...

Pro rychlé spuštění a zastavení testů kontejnerů existuje praktický nástroj nazvaný testcontainers. Najdete tam knihovny pro mnoho programovacích jazyků, včetně Javy.

Nejprve musíte do pom.xml přidat nějaké závislosti :

       <!-- 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>

Musíte aktualizovat testy, abyste mohli používat testovací kontejnery, které spustí databázi při každém testovacím běhu. Přidejte do testu anotaci a pole, abyste jej mohli použít:

//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);
   }

Při každém provedení testu se za vás spustí databáze, což vám umožní při provádění testů použít skutečnou databázi. Veškerá kabeláž, její nastavení, spouštění a čištění se provádí za vás.

Ukotvení aplikace

Ukotvení vaší aplikace pomocí jednoduchých nástrojů Dockeru je možné, ale nedoporučuje se.

Můžete sestavit svou aplikaci, použít základní kontejner obsahující Javu a zkopírovat a spustit aplikaci. Existuje však mnoho úskalí, a to je případ každého jazyka a rámce. Vždy tedy hledejte nástroje, které vám usnadní život.

V tomto příkladu použijete kontejnery Jib a distroless ke snadnému vytvoření kontejneru Docker. Použitím obou v kombinaci získáte minimální, bezpečný a reprodukovatelný kontejner, který funguje stejným způsobem lokálně i ve výrobě.

Chcete-li používat Jib, musíte jej přidat jako plugin maven přidáním do 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>

Nyní můžete vytvořit bitovou kopii a spustit aplikaci:

# 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)

Aplikace se spouští s hostitelem síťového režimu --net=host , což usnadňuje pouhé připojení k databázi, kterou jste spustili. Případně můžete vytvořit docker network a spusťte oba ve stejné síti.

Svůj kontejner můžete odeslat do registru kontejnerů a odkazovat na něj z libovolného nástroje pro orchestraci kontejnerů, abyste spustili svou aplikaci v produkci.