Containerizing an app.

Docker tất cả là về việc lấy ứng dụng và chạy chúng trong container. Quá trình lấy ứng dụng, cấu hình nó để chạy trên container được gọi là containerizing hay Dockerizing.

Tổng quan.

• Container tất cả là về ứng dụng.
• Quá trình containerzing một ứng dụng trông như thế nào:
  1. Bắt đầu với code của ứng dụng.
  2. Tạo một Dockerfile để miêu tả ứng dụng của bạn
  3. Đưa Dockerfile này vào lệnh ` docker image build`.
  4. Chờ Docker build ứng dụng của bạn thành một docker image.

     Đóng gói một ứng dụng đơn.

     Lấy code của ứng dụng.

     Ví dụ này sử dụng ứng dụng được clone từ github: https://github.com/nigelpoulton/psweb.git

Clone ứng dụng:

$ git clone https://github.com/nigelpoulton/psweb.git
Cloning into 'psweb'...
remote: Enumerating objects: 15, done.
remote: Total 15 (delta 0), reused 0 (delta 0), pack-reused 15
Unpacking objects: 100% (15/15), done.

$ cd psweb
$ ls -l
total 28
-rw-r--r-- 1 root root  341 Thg 5  3 11:31 app.js
-rw-r--r-- 1 root root  216 Thg 5  3 11:31 circle.yml
-rw-r--r-- 1 root root  338 Thg 5  3 11:31 Dockerfile
-rw-r--r-- 1 root root  421 Thg 5  3 11:31 package.json
-rw-r--r-- 1 root root  370 Thg 5  3 11:31 README.md
drwxr-xr-x 2 root root 4096 Thg 5  3 11:31 test
drwxr-xr-x 2 root root 4096 Thg 5  3 11:31 views

• Code đã được lấy về.

  Kiểm tra dockerfile.

• File Dockerfile trong repo trên là file mô tả ứng dụng chỉ cho Docker làm sao để build nó thành một image.
• Build context là thư mục lưu trữ ứng dụng, thường là nên để Dockerfile trong thư mục root của build context.
• Tên của file Dockerfile phải bắt đầu bằng chữ D viết in hoa và viết trong một từ ( “dockerfile” hay “Docker file” là không hợp lệ)
• Xem nội dung của Dockerfile trong ví dụ;

  # Test web-app to use with Pluralsight courses and Docker Deep Dive book
  # Linux x64
  FROM alpine
  LABEL maintainer="nigelpoulton@hotmail.com"
  # Install Node and NPM
  RUN apk add --update nodejs nodejs-npm
  # Copy app to /src
  COPY . /src
  WORKDIR /src
  # Install dependencies
  RUN  npm install
  EXPOSE 8080
  ENTRYPOINT ["node", "./app.js"]
  

• Dockerfile có hai mục đích chính:
  • Mô tả ứng dụng.
  • Nói cho Docker cách đóng gói ứng dụng.
• Tất cả các Dockerfile bắt đầu với chỉ dẫn FROM. Nó là lớp nền tảng của image để chủ định image nền tảng để chạy ứng dụng.

• LABLE: Lable là những giá trị đơn giản và là cách tốt nhất để thêm siêu dữ liệu vào một image. - RUN: để thực thi một câu lệnh trong quá trình build image. Chỉ dẫn RUN apk add --update nodejs nodejs-npm sử dụng package manager apk của Alpine để cài đặt nodejs và nodejs-npm vào image. RUN cài một package mới như một lớp mới ở trên cùng của image.

• Chỉ dẫn COPY . /src copy file ứng dụng từ build context. Nó copy file và image như một lớp mới.

• Chỉ dẫn WORKDIR để thiết lập thư mục làm việc. chỉ dẫn này không tạo thêm một lớp mới.

• Chỉ dẫn RUN npm install sử dụng npm để cài đặt những thành phần phụ thuộc của ứng dụng được liệt kê trong package.json ở build context.

• EXPOSE 8080 để expose ứng dụng ra port 8080. Nó thêm vào image dưới dạng metadata không phải là một lớp của image
• Cuối cùng, ENTRYPOINT để chỉ định ứng dụng chính mà container sẽ chạy. Nó cũng là metadata và không phải một layer.

  Đóng gói ứng dụng/build image.

• Build image

  ../psweb# docker image build -t web:latest .
  Sending build context to Docker daemon  80.38kB
  Step 1/8 : FROM alpine
  latest: Pulling from library/alpine
  bdf0201b3a05: Pull complete 
  Digest: sha256:28ef97b8686a0b5399129e9b763d5b7e5ff03576aa5580d6f4182a49c5fe1913
  Status: Downloaded newer image for alpine:latest
  ...
  Step 8/8 : ENTRYPOINT ["node", "./app.js"]
   ---> Running in 4f42b7174ab2
  Removing intermediate container 4f42b7174ab2
   ---> 2acf66ff7a0a
  Successfully built 2acf66ff7a0a
  Successfully tagged web:latest
  

• Kiểm tra image có trong local repository chưa:

  # docker image ls
  REPOSITORY             TAG                 IMAGE ID            CREATED             SIZE
  web                    latest              2acf66ff7a0a        3 minutes ago       69MB
  

• đã đóng gói thành công.

  Pushing Image.

• Push image lên Docker Hub là một cách thông dụng để lưu trữ, và cho người khác cùng sử dụng image đó.
• Login vào docker hub từ cmd:

  # docker login
  Username: lamth
  Password: 
  Login Succeeded
  

• Docker cần những thông tin sau để push một image:
  • Regitry
  • Repository
  • Tag
• Nếu không có các giá trị, Docker sẽ tự giả định Registry=docker.io và Tag=latest, không có giá trị mặc định cho repository.
• Thêm tag cho image, để có thể push lên Docker Hub: # docker image tag web:latest lamth/web:latest lệnh docker image tag <tag cũ> <tag mới> là để thêm tag cho image chứ không ghi đè lên tag cũ.

  # docker image ls
  REPOSITORY             TAG                 IMAGE ID            CREATED             SIZE
  lamth/web              latest              2acf66ff7a0a        16 hours ago        69MB
  web                    latest              2acf66ff7a0a        16 hours ago        69MB
  

• Push image lên Docker Hub:

  # docker image push lamth/web:latest
  The push refers to repository [docker.io/lamth/web]
  f941dc00b27a: Pushed 
  6624dbf217ff: Pushed 
  8dd5da23be75: Pushed 
  a464c54f93a9: Mounted from library/alpine 
  latest: digest: sha256:d696c1fceca0367d044a9d9a43ea8630016ba80d0180897b47f1b79b82338ef9 size: 1160
  

  Chạy ứng dụng

• Ứng dụng chúng ta vừa dóng gói là một web server đơn giản chạy trên port 8080.
• Chạy ứng dụng:

  # docker container run -d --name testweb \
  -p 80:8080 \
  web:latest
  

• Flag -d là để container chạy ngầm, flag -p 80:8080 là để map port 80 của host với port 8080 trong container.

  # docker container ls
  ID   IMAGE      COMMAND         STATUS    PORTS 
  49.. web:latest "node ./app.js" UP 6 secs 0.0.0.0:80->8080/tcp
  

• Kiểm tra:

Sâu hơn, tối hơn

• ứng dụng đã được đóng gói, hãy tìm hiểu sâu hơn về cách nó hoạt động.
• Những dòng comment trong Dockerfile bắt đầu với ký tự #
• Những dòng không phải là comment là những Chỉ dẫn (Instructions). Các chỉ dẫn có cấu trúc INSTRUCTION argument. Tên các chỉ dẫn không phân biệt viết HOA hay viết thường, nhung nó thường được viết HOA.
• Lệnh docker image build phân tích Dockerfile thành từng dòng một từ trên xuống dưới
• Một số Instruction tạo một layer mới trong image (Ví dụ: FROM, RUN và COPY), trong khi các instruction chỉ thêm metadata vào image (Ví dụ: EXPOSE, WORKDIR, ENV và ENTRYPOINT). Có thể hiểu là nếu chỉ dẫn thêm nội dung như một file hay một chương trình thì nó sẽ thêm một layer mới, còn nếu chỉ dẫn chỉ thêm các chỉ dẫn để build image thì nó sẽ tạo các metadata.
• Có thể xem các instruction đã sử dụng để build image với lệnh docker image history. ```bash $ docker image history web:latest IMAGE CREATED BY SIZE c6..18e /bin/sh -c #(nop) ENTRYPOINT [“node” “./a… 0B 334..bf0 /bin/sh -c #(nop) EXPOSE 8080/tcp 0B b27..eae /bin/sh -c npm install 14.1MB 932..749 /bin/sh -c #(nop) WORKDIR /src 0B 052..2dc /bin/sh -c #(nop) COPY dir:2a6ed1703749e80… 22.5kB c1d..81f /bin/sh -c apk add –update nodejs nodejs-npm 46.1MB 336..b92 /bin/sh -c #(nop) LABEL maintainer=nigelp… 0B 3fd..f02 /bin/sh -c #(nop) CMD [“/bin/sh”] 0B

/bin/sh -c #(nop) ADD file:093f0723fa46f6c... 4.15MB ``` - Có hai điều đáng chú ý trong output trên; 1. Mỗi dòng tương ứng với một instruction trong Dockerfile. Cột CREATED BY liệt kê chính sác các Chỉ dẫn trong Dockerfile được thực thi. 2. Chỉ có 4 trong các instruction thực thi tạo ra các lớp mới. Các instruction còn lại cũng trong như là tạo một lớp mới nhưng chúng chỉ thêm metadata vào image. Việc lệnh docker image history liệt kê tất cả intruction là một bằng chứng về các xây dựng và mô hình các lớp trong image. - sử dụng lệnh `docker image inspect` để kiểm chứng là 4 layer đã được tạo: ```bash $ docker image inspect web:latest "RootFS": { "Type": "layers", "Layers": [ "sha256:a464c54f93a...900da9", "sha256:8dd5da23be7...23bdc9", "sha256:6624dbf217f...69923d", "sha256:f941dc00b27...1bb1bc" ] } ``` - Sử dụng các image từ các official repo với FROM được coi là tốt trong thực tế vì nó ít lỗ hổng, người ta cũng thường bắt đầu(FROM) với các image nhỏ vì nó cũng là giảm đi các lỗ hổng tiềm năng. Quy trình cơ bản là: `chạy một container tạm thời > chạy các chỉ dẫn Dockerfile trong container đó > lưu kết quả thành một image > xóa container tạm thời đi` ### Moving to production with Multi-stage Builds - Với Docker Image, *Càng lớn càng đểu*. - **Lớn** = chậm = khó làm việc với = càng nhiều lỗ hổng bảo mật và bề mặt tấn công. - Vì một số lý do, Docker Image nên nhỏ. Image chỉ chứa những thứ *cần* để chạy ứng dụng. - Dữ cho Image nhỏ là một việc khó. - Ví dụ khi bạn đóng gói một ứng dụng, nhưng nó cần có một vài file mà phải cài đặt các package, chương trình khác để có được file này cho chương trình chính. Việc này sẽ làm cho image của bạn sẽ bị lớn, không tốt. - Có thể giải quyết vấn đề trên với *builder pattern* nhưng nó cần ít nhất hai Dockerfiles, việc kết hợp chúng lại là rất phức tạp. - Multi-Stage builds sinh ra để giải quyết vấn đề này, nó là vệ sự tối ưu hóa bản dựng(build) mà không có sự phức tạp. - Ở tầng cao: Với multi-stage builds, chúng ta có một Dockerfile chứa nhiều chỉ dẫn FROM. mỗi FROM là một build stage mới mà có thể dễ dàng COPY những gì mà các stage trước tạo ra (file,...) - Ví dụ Dockerfile sau: ```bash FROM node:latest AS storefront WORKDIR /usr/src/atsea/app/react-app COPY react-app . RUN npm install RUN npm run build FROM maven:latest AS appserver WORKDIR /usr/src/atsea COPY pom.xml . RUN mvn -B -f pom.xml -s /usr/share/maven/ref/settings-docker.xml dependency\ :resolve COPY . . RUN mvn -B -s /usr/share/maven/ref/settings-docker.xml package -DskipTests FROM java:8-jdk-alpine AS production RUN adduser -Dh /home/gordon gordon WORKDIR /static COPY --from=storefront /usr/src/atsea/app/react-app/build/ . WORKDIR /app COPY --from=appserver /usr/src/atsea/target/AtSea-0.0.1-SNAPSHOT.jar . ENTRYPOINT ["java", "-jar", "/app/AtSea-0.0.1-SNAPSHOT.jar"] CMD ["--spring.profiles.active=postgres"] ``` - Các stage dưới có thể sử dụng tài nguyên của các stage ở trên. Ở ví dụ trên, stage *production* sử dụng tài nguyên từ stage *storefront* và *appserver* ``` COPY --from=storefront /usr/src/atsea/app/react-app/build/ . <...> COPY --from=appserver /usr/src/atsea/target/AtSea-0.0.1-SNAPSHOT.jar . ``` - *Image khi được built với multi-stage sẽ có dung lượng của image ở stage cuối, các tài nguyên của image đó và các tài nguyên mà nó sử dụng của các stage trên*. Vì vậy, Image sẽ rất nhẹ. ## Containerizing an app - The commands - docker image build is the command that reads a Dockerfile and containerizes an application. The -t flag tags the image, and the -f flag lets you specify the name and location of the Dockerfile. With the -f flag, it is possible to use a Dockerfile with an arbitrary name and in an arbitrary location. The build context is where your application files exist, and this can be a directory on your local Docker host or a remote Git repo. - The FROM instruction in a Dockerfile specifies the base image for the new image you will build. It is usually the first instruction in a Dockerfile. - The RUN instruction in a Dockerfile allows you to run commands inside the image which create new layers. Each RUN instruction creates a single new layer. - The COPY instruction in a Dockerfile adds files into the image as a new layer. It is common to use the COPY instruction to copy your application code into an image. - The EXPOSE instruction in a Dockerfile documents the network port that the application uses. - The ENTRYPOINT instruction in a Dockerfile sets the default application to run when the image is started as a container. - Other Dockerfile instructions include LABEL, ENV, ONBUILD, HEALTHCHECK, CMD and more…