Apa itu Doker? Pelajari Cara Menggunakan Wadah – Dijelaskan dengan Contoh

Wadah adalah alat penting untuk pengembangan perangkat lunak saat ini. Menjalankan aplikasi di lingkungan apa pun menjadi mudah saat Anda memanfaatkan container.

Teknologi paling populer untuk menjalankan container adalah Docker, yang berjalan di sistem operasi apa pun.

Dalam posting blog ini, Anda akan belajar menggunakan Docker untuk 3 kasus penggunaan paling penting. Anda akan mempelajari cara:

• jalankan database secara lokal menggunakan Docker,
• jalankan pengujian otomatis menggunakan database dockerized,
• jalankan aplikasi Anda secara lokal dan dalam produksi menggunakan Docker.

Anda akan menggunakan aplikasi Java Spring Boot, tetapi semua pembelajaran berlaku untuk setiap bahasa pemrograman pilihan Anda.

Untuk menjalankan semua contoh, Anda perlu:

• Instal Docker
• Instal Java

Jalankan Aplikasi Terisolasi Menggunakan Docker

Docker menghilangkan tugas konfigurasi biasa yang berulang dan digunakan di seluruh siklus pengembangan untuk pengembangan aplikasi yang cepat, mudah, dan portabel – desktop dan cloud. (Sumber:https://www.docker.com/use-cases/)

Inti dari kekuatan super Docker adalah memanfaatkan apa yang disebut cgroups untuk menciptakan lingkungan yang ringan, terisolasi, portabel, dan berkinerja tinggi, yang dapat Anda mulai dalam hitungan detik.

Mari kita lihat bagaimana Anda dapat menggunakan Docker untuk menjadi lebih produktif.

Wadah Basis Data

Menggunakan Docker, Anda dapat memulai banyak jenis database dalam hitungan detik. Mudah, dan tidak mencemari sistem lokal Anda dengan persyaratan lain yang Anda perlukan untuk menjalankan database. Semuanya dikemas dengan wadah Docker.

Dengan mencari hub.docker.com, Anda dapat menemukan container siap pakai untuk banyak database.

Menggunakan docker run perintah, Anda dapat memulai wadah 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

Perintah ini menggunakan fitur lanjutan untuk menjalankan container Docker:

• -v "$PWD/data" memetakan direktori lokal Anda ./data ke wadah buruh pelabuhan, yang memungkinkan Anda memulai wadah buruh pelabuhan tanpa kehilangan data Anda,
• -p 3306:3306 memetakan port kontainer 3306 ke mesin kami sehingga aplikasi lain dapat menggunakannya,
• -e MYSQL_DATABASE=my-database menetapkan variabel lingkungan untuk membuat database baru yang disebut my-database secara otomatis,
• -e MYSQL_ROOT_PASSWORD=admin-password menyetel variabel lingkungan untuk menyetel sandi admin,
• --rm menghapus wadah saat dihentikan.

Variabel lingkungan ini dan lainnya didokumentasikan di halaman gambar Docker.

Cara Menggunakan Wadah Basis Data Untuk Pengembangan

Anda akan menggunakan tumpukan teknologi populer untuk membangun aplikasi web berbasis Java dan Spring Boot. Untuk fokus pada bagian Docker, Anda dapat mengkloning aplikasi demo sederhana dari Accessing JPA Data With Rest Guide resmi.

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

# Open the final application folder
cd complete

Aplikasi dilengkapi dengan database dalam memori, yang tidak berharga untuk produksi karena tidak memungkinkan beberapa layanan untuk mengakses dan mengubah satu database. Database MySQL lebih cocok untuk menskalakan aplikasi Anda ke lebih banyak baca dan tulis.

Oleh karena itu, tambahkan driver MySQL ke pom.xml Anda :

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

Sekarang, Anda perlu menambahkan konfigurasi untuk terhubung ke database Anda dengan menambahkan file konfigurasi 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

Anda sekarang dapat memulai aplikasi dan memanggil titik akhir yang ada:

# 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

Anda berhasil menggunakan aplikasi dasar Anda, yang menulis dan membaca data di database Anda. Menggunakan database MySQL Docker memberi Anda database yang kuat dalam hitungan detik, dan Anda dapat menggunakannya dari aplikasi apa pun.

Cara Menggunakan Wadah Basis Data untuk Pengujian Integrasi

Aplikasi sudah memiliki tes yang mengharapkan database berjalan. Namun, karena Anda mengganti database dalam memori dengan database MySQL yang sebenarnya, pengujian tidak akan berhasil jika Anda menghentikan 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 ...

Untuk memulai dan menghentikan container yang menjalankan pengujian dengan cepat, ada alat praktis yang disebut testcontainers. Di sana Anda akan menemukan perpustakaan untuk banyak bahasa pemrograman, termasuk Java.

Pertama, Anda perlu menambahkan beberapa dependensi ke pom.xml Anda :

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

Anda perlu memperbarui pengujian untuk menggunakan testcontainers, yang memulai database pada setiap pengujian. Tambahkan anotasi dan bidang ke pengujian untuk menggunakannya:

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

Untuk setiap eksekusi pengujian, database dimulai untuk Anda, yang memungkinkan Anda untuk menggunakan database aktual saat Anda menjalankan pengujian. Semua pengkabelan, penyiapan, pengaktifan, dan pembersihan dilakukan untuk Anda.

Dockerize Aplikasi Anda

Dockerisasi aplikasi Anda menggunakan alat Docker sederhana dimungkinkan tetapi tidak disarankan.

Anda dapat membangun aplikasi Anda, menggunakan wadah dasar yang berisi Java dan menyalin dan menjalankan aplikasi Anda. Tetapi ada banyak jebakan, dan ini adalah kasus untuk setiap bahasa dan kerangka kerja. Jadi selalu cari alat yang membuat hidup Anda lebih mudah.

Dalam contoh ini, Anda akan menggunakan Jib dan container distroless untuk membuat container Docker dengan mudah. Menggunakan keduanya dalam kombinasi memberi Anda wadah minimal, aman, dan dapat direproduksi, yang bekerja dengan cara yang sama secara lokal dan dalam produksi.

Untuk menggunakan Jib, Anda perlu menambahkannya sebagai plugin maven dengan menambahkannya ke pom.xml Anda :

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

Anda sekarang dapat membuat gambar dan menjalankan aplikasi:

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

Aplikasi dimulai dengan mode jaringan host --net=host , yang memudahkan untuk menyambungkan ke database yang Anda mulai. Atau, Anda dapat membuat docker network dan mulai keduanya di jaringan yang sama.

Anda dapat mendorong container ke registry container dan merujuknya dari alat orkestrasi container apa pun untuk menjalankan aplikasi Anda dalam produksi.