DEV Community: Jayden Nguyen

How to install Docker Compose on Ubuntu 18.04

Jayden Nguyen — Mon, 26 Jul 2021 02:54:08 +0000

Compose is a tool for defining and running multi-container Docker applications. With Compose, you use a YAML file to configure your application’s services. read more for detail Docker Compose Documentation

In this article, I will introduce setup Docker Compose on Ubuntu 18.04 or later version.

1. Install Docker Compose on Ubuntu Repository

Ubuntu Repository will provide stable version and update for automationally

sudo apt update

Then open your terminal and input command:

sudo apt install docker-compose

It is take few minutes for downloading and installation.
To verify version installation successfully on your system, by command:

docker-compose version

2. Install Docker Compose on Ubuntu by GitHub Repository

GitHub is a inventory contain a lot of repository from organization, developer, etc. Contribute to the open source community.

Install and updated version of Docker utility, copy the following command:

sudo wget –O /usr/local/bin/docker-compose https://github.com/docker/compose/releases/download/1.25.0/docker-compose-Linux-x86_64

Give the command assign permission to executable file:

sudo chmod +x /usr/local/bin/docker-compose

Then permission will be applied to the executable file after this command
To verify version installation successfully on your system, by command:

docker-compose version

How to uninstall Docker Compose on Ubuntu 18.04

The file Docker Compose can be deleted from your system when we remove it is binary

Given command to remove it:

sudo rm /usr/local/bin/docker-compose

Conclusion

📚 Recommended Books

Clean Code:Book

HTTP: The Definitive Guide

Clean architecture: Book

📱 Social Media

Blog: KhanhNHB Tech

Twitter: KhanhNHB

Youtube: KhanhNHB Tech

GitHub: KhanhNHB

Email: khanhnhbse@gmail.com

How to build CRUD Spring Boot JPA with MySQL Container on Ubuntu 18.04

Jayden Nguyen — Mon, 26 Jul 2021 02:42:05 +0000

I. Introduction

In this article you learn about Spring Boot JPA allowing to build simple backend applications by connect MySQL database container by write docker-compose file. Spring Data JPA is a great choice allowing to speed your development and focus on the business logic.

Technology you can learn in this tutorial:

Spring Boot JPA
Build Docker Compose for MySQL
CRUD operation for simple

Tool support to implementation:

IDE Intellij for coding (you can choose other IDE, it is up for you)
Postman, for manipulate HTTP request
Docker and Docker Compose, for build MySQL container. You can read more install on Ubuntu 18.04 Install Docker on Ubuntu 18,04, Install Docker Compose on Ubuntu 18.04

GitHub repository at here blog repository

Video reference for coding at here

II. Implement

Step 1: Initial Project Spring Boot Maven

In this project I will using Maven. Maven is a build automation tool used for primarily for Java project.

Open Intellij choose Spring Initializr edit name project, and choose Project SDK, Java version.

Option you can create project on website at here, click download and extract import project by Intellij.

You can pick add dependency when initial project Spring Data JPA, Spring Web, and MySQL Driver to exploring. or add manual in file pom.xml.
POM or Project Object Model. It is the fundamental unit of work in Maven. It is a file XML contain information about project and configuration detail used by Maven, read more detail at here.

 <dependency>
        <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
 </dependency>

For the dependency you can see it is a format XML. It is a naming convention:

groupId: A uniquely identified name of project or organization.
artifactId: A unique name of project. It is mention about packages .
version: The version of project.
scope: Specfic scope for denpendency. There are five scope available:
- compile: It is default when none specific scope provided.
- provided: The dependencies should be provided at runtime JDK or a container.
- runtime: The dependencies with this scope are required at runtime.
- test: Test is aren't transitive and are only present for test and execution classpaths.
- system: The scope is similar to the provided scope. The difference is that system requires us to directly point to the specific jar on the system.

Step 2: Implement `docker-compose.file` to start MySQL

Create file docker-compose.file in root project to run MySQL container.

Docker Compose is tool is defined and running multi-container. It is convention YML file to configuration your application's services. Using Compose a basically a three-step process:
- Create Dockerfile to define environment your apps. It can be reproduces anywhere.
- Create docker compose. Define in your app docker-comse.yml. They can run together in an isolated environment.
- Run docker compose up to start your application's services by command docker-compose up.

Note: For now I skip Dockerfile. I will create Dockerfile in session later.

version: '3'

services:
  mysql:
    image: mysql:8.0
    container_name: blog_mysql
    volumes:
      - db_mysql:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: password
      MYSQL_USER: blogger
      MYSQL_PASSWORD: blogger
      MYSQL_DATABASE: blog
    ports:
      - 3306:3306

volumes:
  db_mysql:

version: The version of compose. It is number spring format.
services: The make up your application's services.
mysql: The unique name specific service.
image: Before colon is the name service you want use, and after colon is version service. Recommend specific version if image will be change in the future.
container_name: The unique name container. It will be generate random if none provided.
volume: It is make persist data. if it finds any containers from previous runs, it copies the volumes from the old container to the new container. This process ensures that any data you’ve created in volumes isn’t lost. Before colon name db_mysql is a origin folder container script, after colon name is destination /var/lib/mysql.
environment: Is is make permission to access container MySQL to manipulate data.
port: The port to access container. Before colon is a port 3306 for host machine connect, and after colon the port 3306 is MySQL Container.

Step 3: Configuration `application.properties` to connect MySQL

To connect MySQL Container we will be configuration from Spring Boot application at application.properties in resources folder

spring.jpa.hibernate.ddl-auto=update
spring.datasource.url=jdbc:mysql://localhost:3306/blog
spring.datasource.username=blogger
spring.datasource.password=blogger
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

spring.jpa.hibernate.ddl-auto: It can be none, update, create, create-drop see the more detail Hibernate Document
- none: Default MySQL, no change is make database structure. It is good security for the production state.
- update: The database will be change by Hibernate if the entity given structures.
- create: Create database every time but does not drop it on close.
- create-drop: Create database and drops when SessionFactory close.
spring.datasource.url: Given URL connect to MySQL Container for datasource.
spring.datasource.username: Given username connect to MySQL for datasource.
spring.datasource.password: Give password connect to MySQL for datasource.
spring.datasource.driver-class-name: Given name driver MySQL for datasource.

Step 4: Create `@Entity`, Repository, `@Controller`

Define Blog class Entity. The Hibernate will be automatically translate entity Blog to table Blog in database.

package com.khanhnhb.blog.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Blog {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    public Integer id;
    public String title;
    public String content;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }
}

@Entity annotation this tells Hibernate to make a table out of this class.

Define Blog Repository to manipulate interface CRUD records.

package com.khanhnhb.blog.repository;

import com.khanhnhb.blog.model.Blog;
import org.springframework.data.repository.CrudRepository;

public interface BlogRepository extends CrudRepository<Blog, Integer> {
}

CRUD refers Create, Read, Update, Delete
Spring automatically implements this repository interface into a beans the same name blogRepository.

Define Blog Controller to using HTTP request.

package com.khanhnhb.blog.controller;

import com.khanhnhb.blog.model.Blog;
import com.khanhnhb.blog.repository.BlogRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

@Controller
@RequestMapping(path = "/blogs")
public class BlogController {

    @Autowired
    private BlogRepository blogRepository;

    @PostMapping()
    public @ResponseBody Blog createBlog(@RequestBody Blog newBlog) {
        return blogRepository.save(newBlog);
    }

    @GetMapping()
    public @ResponseBody Iterable<Blog> getAll() {
        return blogRepository.findAll();
    }

    @GetMapping(path = "{id}")
    public @ResponseBody Blog getOne(@PathVariable Integer id) {
        return blogRepository.findById(id).get();
    }

    @PutMapping(path = "{id}")
    public @ResponseBody Blog updateBlog(@PathVariable Integer id, @RequestBody Blog updateBlog) {
        Blog blog = blogRepository.findById(id).get();

        blog.setTitle(updateBlog.getTitle());
        blog.setContent(updateBlog.getContent());

        return blogRepository.save(blog);

    }

    @DeleteMapping(path = "{id}")
    public @ResponseBody Integer deleteBlog(@PathVariable Integer id) {
        Blog blog = blogRepository.findById(id).get();
        blogRepository.delete(blog);
        return blog.getId();
    }
}

@Controller annotation it means that this class is a Controller.
@RequestMapping annotation it means URL's start with /blog (after Application path)
@Autowire annotation its means to get the bean called blogRepository. Which is auto-generated by Spring when application start, we will use it to handle the data.
@PostMapping annotations its mean map ONLY POST Requests.
@RequestBody annotations its mean pass value in body request.
@ResponseBody annotations its mean returned object data type (Blog, Integer, ...).
@GetMapping annotations its mean map ONLY GET Requests.
@PathVariable annotations its mean can be use handle template variables in the request URL.
@PutMapping annotations its mean map ONLY PUT Requests.
@DeleteMapping annotations its mean map ONLY DELETE Requests.

Step 5: Make HTTP request with Postman

Create Blog

POST: localhost:8080/blogs

body: 
{
    "title": "Exploring Spring Data JPA",
    "content: "Create first blog"
}

Read all Blog

GET: localhost:8080/blogs

Read blog by id

GET: localhost:8080/blogs/1

Update blog

PUT: localhost:8080/blogs/1

body: 
{
    "title": "Exploring Spring Data JPA and MySQL",
    "content: "Modify first blog"
}

Delete blog
DELETE: localhost:8080/blogs/1

III. Conclusion

In this article you learn about Spring Boot JPA allowing to build simple backend applications by connect MySQL database container by write docker-compose file.

📚 Recommended Books

Clean Code:Book

HTTP: The Definitive Guide

Clean architecture: Book

📱 Social Media

Blog: KhanhNHB Tech

Twitter: KhanhNHB

Youtube: KhanhNHB Tech

GitHub: KhanhNHB

Youtube: KhanhNHB Tech

GitHub: KhanhNHB

How to run image Elasticsearch Container on Ubuntu 18.04

Jayden Nguyen — Fri, 16 Jul 2021 15:33:44 +0000

Elasticsearch is a search engine based on the Lucene library. It provides a distributed, multitenant-capable full-text search engine with an HTTP web interface and schema-free JSON documents. To read more about at Elasticsearch Document.

In this post I will introduction setup about Elasticsearch container on Ubuntu 18.04. It is make sure you already install docker please check more content at Install Docker.

There are have 3 steps:

Step 1: Downloading image Elasticsearch

Pull Image Elasticsearch on Docker Hub by command:

docker pull elasticsearch:tag

Tag is a specific version image. Recommended specific for version if image have any change version in the future

Verify pull image success by command:

docker images

Step 2: Running in Development Mode for start container

docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" elasticsearch:tag

Some describes:

-d: It is detach running container in background
--name: The name of container
-p: Port container will expose to host
-e: It is environment for container

Verify running container success

The command just shows running containers

docker ps

To see all containers, use flag -a

docker ps -a

Open browser access localhost:9200

Step 3: Stop running container and remove container

You can stop container by id or by name

docker stop container_id

docker stop container_name

Verify stop container by command

docker ps -a

docker ps

Conclusion

In this post I have implemented setup Elasticsearch by pull image, run, stop and remove container on Ubuntu 18.04. To learn more about Docker Document, and Elastichsearch Document.

If you have any question please comment or contact me.

Author: @NHB Khanh

📚 Recommended Books

Clean Code:Book

HTTP: The Definitive Guide

Clean architecture: Book

📱 Social Media

Blog: KhanhNHB Tech

Twitter: KhanhNHB

Email: khanhnhbse@gmail.com

How to install Docker on Ubuntu 18.04

Jayden Nguyen — Fri, 16 Jul 2021 14:35:30 +0000

Docker is a set of platform as a service products that use OS-level virtualization to deliver software in packages called containers. You can references to documents at this https://www.docker.com/ .

Step 1: Need to update software repositories. Run the following command:

sudo apt-get update

Step 2: Install Docker on Ubuntu 18.04

To install latest version you can run command

sudo apt install docker-ce docker-ce-cli containerd.io

To install specific version docker

apt list -a docker-ce

Then install specific version

sudo apt install docker-ce= docker-ce-cli= containerd.io

You can verify Docker service after install. It is start automation when install completed

sudo systemctl status docker

Step 3: Execute docker on-non root user

sudo usermod -aG docker $USER

Finally, you can make verify docker is install success

docker run hello-world

Uninstall docker

To stop all running containers and Docker instance

docker container stop $(docker container ls -aq)

docker system prune -a --volumes

Now uninstall Docker as any other package installed with apt

sudo apt purge docker-ce

sudo apt autoremove

Conclusion

In this post I will introduction way to install docker on Ubuntu 18.04. To learn more about Docker you, check out official Docker Offical Document

If you have any question please comment or contact me.

Author: @NHB Khanh

Facebook: facebook.com/khanhnhb

Email: khanhnhbse@gmail.com

DEV Community: Jayden Nguyen

How to install Docker Compose on Ubuntu 18.04

1. Install Docker Compose on Ubuntu Repository

2. Install Docker Compose on Ubuntu by GitHub Repository

How to uninstall Docker Compose on Ubuntu 18.04

Conclusion

How to build CRUD Spring Boot JPA with MySQL Container on Ubuntu 18.04

I. Introduction

II. Implement

Step 1: Initial Project Spring Boot Maven

Step 2: Implement docker-compose.file to start MySQL

Step 3: Configuration application.properties to connect MySQL

Step 4: Create @Entity, Repository, @Controller

Step 5: Make HTTP request with Postman

III. Conclusion

How to run image Elasticsearch Container on Ubuntu 18.04

Conclusion

How to install Docker on Ubuntu 18.04

Conclusion

Step 2: Implement `docker-compose.file` to start MySQL

Step 3: Configuration `application.properties` to connect MySQL

Step 4: Create `@Entity`, Repository, `@Controller`