wippppp

Author: ntk148v

docker/build/.secrets

@@ -0,0 +1 @@
+hereisthesensitivedata

docker/build/Dockerfile.unsafe

@@ -0,0 +1,3 @@
+FROM busybox
+COPY .secrets /
+RUN rm .secrets

docker/build/README.md

@@ -0,0 +1,48 @@
+# Build tricks
+
+## 1. Build secrets
+
+Source: <https://docs.docker.com/build/building/secrets/>
+
+A build secret is any piece of sensitive information, such as password or API token, consumed as part of your applications build process.
+
+## 1.1. The wrong way to copy secret
+
+Do you ever try to `COPY` a file with credentials from your Dockerfile and then remove it with `rm` when you don't need it anymore?
+
+```Dockerfile
+FROM busybox
+COPY .secrets /tmp
+RUN rm /tmp/.secrets
+```
+
+Well, **this is so wrong** because you are just deleting the file from that layer but the credentials are still in the layer above.
+
+```shell
+$ docker build -t unsafe . -f Dockerfile.unsafe
+ => [internal] load build definition from Dockerfile.unsafe                                                                                                                                                                      0.1s
+ => => transferring dockerfile: 97B                                                                                                                                                                                              0.0s
+ => [internal] load metadata for docker.io/library/busybox:latest                                                                                                                                                                2.7s
+ => [auth] library/busybox:pull token for registry-1.docker.io                                                                                                                                                                   0.0s
+ => [internal] load .dockerignore                                                                                                                                                                                                0.0s
+ => => transferring context: 2B                                                                                                                                                                                                  0.0s
+ => [internal] load build context                                                                                                                                                                                                0.0s
+ => => transferring context: 58B                                                                                                                                                                                                 0.0s
+ => [1/3] FROM docker.io/library/busybox:latest@sha256:db142d433cdde11f10ae479dbf92f3b13d693fd1c91053da9979728cceb1dc68                                                                                                          0.6s
+ => => resolve docker.io/library/busybox:latest@sha256:db142d433cdde11f10ae479dbf92f3b13d693fd1c91053da9979728cceb1dc68                                                                                                          0.0s
+ => => sha256:db142d433cdde11f10ae479dbf92f3b13d693fd1c91053da9979728cceb1dc68 10.20kB / 10.20kB                                                                                                                                 0.0s
+ => => sha256:a3e1b257b47c09c9997212e53a0b570c1666501ad26e5bf33461304babab47c7 610B / 610B                                                                                                                                       0.0s
+ => => sha256:517b897a6a8312ce202a85c8a517d820b0fc5b6f5d14ec2a3267906f75680403 372B / 372B                                                                                                                                       0.0s
+ => => sha256:430378704d12f9a980f41ae1a29c587974e1f0234d5dab0765fa95a4d764622e 2.16MB / 2.16MB                                                                                                                                   0.4s
+ => => extracting sha256:430378704d12f9a980f41ae1a29c587974e1f0234d5dab0765fa95a4d764622e                                                                                                                                        0.1s
+ => [2/3] COPY .secrets /tmp                                                                                                                                                                                                     0.1s
+ => [3/3] RUN rm /tmp/.secrets                                                                                                                                                                                                   0.5s
+ => exporting to image                                                                                                                                                                                                           0.1s
+ => => exporting layers                                                                                                                                                                                                          0.0s
+ => => writing image sha256:c5ca80eed7e66549a42da612b81a0e914223e3eef40360f87f0dd84d0090e333                                                                                                                                     0.0s
+ => => naming to docker.io/library/unsafe                                                                                                                                                                                        0.0s
+
+$ docker history unsafe
+
+$ docker run -it --rm
+```

docker/overlayfs/README.md

@@ -0,0 +1,87 @@
+# Docker and OverlayFS
+
+Source:
+
+- <https://www.kernel.org/doc/Documentation/filesystems/overlayfs.txt>
+
+Trong bài post này, chúng ta sẽ nghiên cứu về OverlayFS và cách Docker ứng dụng OverlayFS để làm việc với các layers. Trước tiên, hãy cùng tìm hiểu về OverlayFS
+
+## 1. OverlayFS
+
+OverlayFS, một dạng "union filesystem" cho phép nhiều filesystem có thể nằm chồng lên nhau (overlaid). Thay đổi được ghi nhận ở `upper` filesystem, trong khi `lower` filesystem giữ nguyên, giúp giảm dung lượng lưu trữ.
+
+Như vậy, hiểu đơn giản, OverlayFS bao gồm:
+
+- `lower`: read-only, filesystem gốc, không thay đổi.
+- `upper`: read-write, filesystem lưu trữ các thay đổi (thay đổi/xóa/tạo mới).
+- `merged`: filesystem kết hợp dữ liệu của `upper` và `lower`.
+
+![](./upper-lower-dir-768x371.png)
+
+Để hiện thực hóa ý tưởng trên, cùng khởi tạo một overylay filesystem. Đầu tiên, khởi tạo các thư mục sau: `upper`, `lower`, `merged`. Bên cạnh đó, OverlayFS cần thêm một thư mục `work`. Đây là một thư mục tạm thời mà OverlayFS sử dụng để lưu trữ các thay đổi trong quá trình ghi vào filesystem. Khi bạn thực hiện thay đổi đối với tập tin trong `upper`, OverlayFS không ghi trực tiếp vào layer này mà thay vào đó lưu trữ các thay đổi vào `work` và sử dụng các thao tác kỹ thuật để "gộp" các thay đổi này lại.
+
+```shell
+% mkdir /tmp/testoverlayfs
+$ cd /tmp/testpverlayfs
+$ mkdir upper lower merged work
+$ echo "lower file" > lower/in_lower.txt
+$ echo "upper file" > upper/in_upper.txt
+# in_both is in both directories
+$ echo "lower file" > lower/in_both.txt
+$ echo "upper file" > upper/in_both.txt
+```
+
+Gộp thư mục `upper` và `lower` bằng lệnh `mount`:
+
+```shell
+$ sudo mount -t overlay overlay -o lowerdir=/tmp/testoverlayfs/lower,upperdir=/tmp/testoverlayfs/upper,workdir=/tmp/testoverlayfs/work /tmp/testoverlayfs/merge
+```
+
+Dùng `tree` để xem danh sách tệp tin trong các thư mục.
+
+```shell
+$ tree
+.
+├── lower
+│   ├── in_both.txt
+│   └── in_lower.txt
+├── merged
+│   ├── in_both.txt
+│   ├── in_lower.txt
+│   └── in_upper.txt
+├── upper
+│   ├── in_both.txt
+│   └── in_upper.txt
+└── work
+    └── work  [error opening dir]
+
+5 directories, 7 files
+```
+
+Tệp tin `in_both.txt` có mặt trong cả `lower` và `upper`, vậy theo lý thuyết, nội dung tệp tin phải được đọc từ `upper`.
+
+```shell
+$ cat merged/in_both.txt
+upper file
+```
+Tạo một tệp tin mới trong `merged`, tệp tin đồng thời cũng được khởi tạo trong `upper`.
+
+```shell
+$ echo "new_file" > merged/new_file
+$ ls */new_file
+merged/new_file  upper/new_file
+```
+
+Sẽ ra sao nếu chúng ta xóa một tệp tin tại `merged`?
+
+```shell
+$ rm merged/in_both.txt
+$ ls -la */in_both.txt
+-rw-rw-r-- 1 kiennt kiennt   11 Thg 12  3 12:33 lower/in_both.txt
+c--------- 2 root   root   0, 0 Thg 12  3 13:09 upper/in_both.txt
+```
+
+- `in_both.txt` vẫn còn ở thư mục `lower`, tệp tin không hề bị thay đổi.
+- Tệp tin đã bị xóa ở merged.
+- Ở `upper`, vẫn còn tồn tại tệp tin `in_both.txt`? Thực ra, tệp tin này là một character device với device number 0/0. Kỹ thuật này được gọi là **whiteout**, đây là cách OverlayFS đánh dấu một tệp tin đã bị xóa tại `upper`.
+