# Gabay sa Pagsisimula sa Docker: Mabilis na Simulan ang Pag-containerize ng Iyong Application

Ang Docker ay naging isang mahalagang bahagi ng modernong pagbuo at pag-deploy ng software. Sa kabila ng napakaraming talakayan tungkol sa Kubernetes, ang Docker pa rin ang ginustong tool ng maraming kumpanya para sa pagbuo, pagsubok, at pag-deploy ng mga application. Dadalhin ka ng artikulong ito sa mabilisang pagsisimula sa Docker, pag-unawa sa mga pangunahing konsepto nito, at magbibigay ng isang praktikal na halimbawa upang matulungan kang simulan ang pag-containerize ng iyong application.

## Mga Pangunahing Konsepto ng Docker

Bago simulan ang pagsasanay, mahalagang maunawaan ang ilang pangunahing konsepto ng Docker:

*   **Image (Larawan):** Ang mga larawan ay mga read-only na template na naglalaman ng lahat ng kailangan para patakbuhin ang isang application: code, runtime environment, mga tool ng system, mga library, at mga dependency. Katulad ng mga virtual machine image, ngunit mas magaan.

*   **Container (Lalagyan):** Ang mga lalagyan ay mga tumatakbong instance na nilikha mula sa isang larawan. Ito ay isang runtime instance ng isang larawan, na naglalaman ng application at lahat ng mga dependency nito. Ang mga lalagyan ay nakahiwalay sa isa't isa, na may sariling mga file system, proseso, at espasyo sa network.

*   **Docker Hub:** Ang Docker Hub ay isang pampublikong repositoryo ng larawan kung saan maaari kang mag-download ng mga pre-built na larawan, o mag-upload ng iyong sariling mga larawan. Katulad ng GitHub, ngunit espesyal para sa mga larawan ng Docker.

*   **Dockerfile:** Ang Dockerfile ay isang text file na naglalaman ng lahat ng mga tagubilin para sa pagbuo ng isang larawan ng Docker. Sa pamamagitan ng pagsulat ng isang Dockerfile, maaari mong i-automate ang proseso ng paglikha ng larawan.

*   **Docker Compose:** Ang Docker Compose ay isang tool para sa pagtukoy at pagpapatakbo ng mga multi-container na Docker application. Pinapayagan ka nitong i-configure ang mga serbisyo ng application gamit ang isang YAML file, at pagkatapos ay simulan o ihinto ang lahat ng mga serbisyo gamit ang isang solong command.

## Pag-install ng Docker

Una, kailangan mong i-install ang Docker. Nagbibigay ang Docker ng mga installation package para sa iba't ibang operating system. Bisitahin ang [Opisyal na Website ng Docker](https://www.docker.com/get-started/) , at sundin ang mga kaukulang tagubilin para sa pag-install.

Pagkatapos ng pag-install, maaari mong patakbuhin ang command na `docker --version` upang i-verify kung tama ang pagkakainstall ng Docker.

## Pag-containerize ng isang simpleng Python Application

Gagawa tayo ng isang simpleng Python application, at gagamitin ang Docker upang i-containerize ito.

### 1. Paglikha ng Python Application

Gumawa ng isang file na pinangalanang `app.py`, na naglalaman ng sumusunod na code:

```python
from flask import Flask
app = Flask(__name__)

@app.route("/")
def hello():
    return "Hello, Docker!"

if __name__ == "__main__":
    app.run(debug=True, host='0.0.0.0')

Ang simpleng Flask application na ito ay magbabalik ng "Hello, Docker!" sa root path na /.

2. Paglikha ng requirements.txt File

Ang application ay nakadepende sa Flask library, kailangan nating lumikha ng isang requirements.txt file upang ideklara ang mga dependency na ito.

Flask

3. Paglikha ng Dockerfile

Gumawa ng isang file na pinangalanang Dockerfile, at idagdag ang sumusunod na nilalaman:

# Gamitin ang opisyal na Python image bilang base image
FROM python:3.9-slim-buster

# Itakda ang working directory
WORKDIR /app

# Kopyahin ang requirements.txt file sa working directory
COPY requirements.txt .

# I-install ang mga dependency
RUN pip install --no-cache-dir -r requirements.txt

Kopyahin ang code ng aplikasyon sa working directory

COPY app.py .

Ilantad ang port 5000

EXPOSE 5000

Tukuyin ang command para sa paglunsad

CMD ["python", "app.py"]

**Paliwanag ng Dockerfile:**

*   `FROM python:3.9-slim-buster`: Tukuyin ang base image bilang isang pinagaan na bersyon ng Python 3.9.
*   `WORKDIR /app`: Itakda ang working directory sa loob ng container bilang `/app`.
*   `COPY requirements.txt .`: Kopyahin ang `requirements.txt` file mula sa kasalukuyang directory patungo sa `/app` directory ng container.
*   `RUN pip install --no-cache-dir -r requirements.txt`: Patakbuhin ang `pip` command sa loob ng container upang i-install ang mga dependency na tinukoy sa `requirements.txt` file. Ang `--no-cache-dir` parameter ay maaaring magpababa sa laki ng image.
*   `COPY app.py .`: Kopyahin ang `app.py` file mula sa kasalukuyang directory patungo sa `/app` directory ng container.
*   `EXPOSE 5000`: Ipahayag na ang container ay makikinig sa port 5000.
*   `CMD ["python", "app.py"]`: Tukuyin ang command na ipapatupad kapag inilunsad ang container.

### 4. Buuin ang Docker Image

Sa directory na naglalaman ng `Dockerfile`, patakbuhin ang sumusunod na command upang buuin ang Docker image:

```bash
docker build -t my-python-app .

• docker build: Ang command upang buuin ang image.
• -t my-python-app: Magtalaga ng pangalan sa image (my-python-app).
• .: Tukuyin ang directory kung saan matatagpuan ang Dockerfile (kasalukuyang directory).

Maaaring tumagal ang proseso ng pagbuo, depende sa bilis ng network at laki ng mga dependency.

5. Patakbuhin ang Docker Container

Gamit ang sumusunod na command upang patakbuhin ang Docker container:

docker run -d -p 5000:5000 my-python-app

• docker run: Ang command upang patakbuhin ang container.
• -d: Patakbuhin ang container sa detached mode (sa background).
• -p 5000:5000: I-map ang port 5000 ng host machine sa port 5000 ng container.
• my-python-app: Tukuyin ang pangalan ng image na gagamitin.

6. Patunayan ang Aplikasyon

Bisitahin ang http://localhost:5000 sa iyong browser, dapat mong makita ang "Hello, Docker!".

7. Ihinto at Tanggalin ang Container

Gamit ang sumusunod na command upang ihinto ang container:

docker stop 

`` Maaaring tingnan ang sa pamamagitan ng docker ps command.

Gamit ang sumusunod na command upang tanggalin ang container:

docker rm 

Panimula sa Docker Compose

Kung ang iyong aplikasyon ay binubuo ng maraming serbisyo, maaari mong gamitin ang Docker Compose upang pamahalaan ang mga ito.

1. Gumawa ng docker-compose.yml File

Gumawa ng file na pinangalanang docker-compose.yml, at idagdag ang sumusunod na nilalaman:

version: "3.9"
services:
  web:
    image: my-python-app
    ports:
      - "5000:5000"

Paliwanag ng docker-compose.yml:* version: "3.9": Tinutukoy ang bersyon ng Docker Compose file.

• services: Tinutukoy ang mga serbisyo ng aplikasyon.
• web: Tinutukoy ang isang serbisyo na pinangalanang "web".
• image: my-python-app: Tinutukoy ang imahe na ginagamit ng serbisyo.
• ports: Tinutukoy ang pagmamapa ng mga port.

2. Simulan ang Aplikasyon

Sa direktoryo na naglalaman ng docker-compose.yml file, patakbuhin ang sumusunod na command upang simulan ang aplikasyon:

docker-compose up -d

• docker-compose up: Ang command upang simulan ang aplikasyon.
• -d: Patakbuhin ang container sa detached mode (hiwalay na mode).

3. Ihinto ang Aplikasyon

Gamit ang sumusunod na command upang ihinto ang aplikasyon:

docker-compose down

Pinakamahusay na Kasanayan sa Seguridad ng Docker

Mula sa talakayan, makikita na ang seguridad ng mga Docker image ay isang mahalagang isyu. Narito ang ilang pinakamahusay na kasanayan sa seguridad ng Docker:

• Gumamit ng Opisyal na mga Image: Hangga't maaari, gumamit ng mga opisyal na image na ibinigay, ang mga image na ito ay karaniwang sumasailalim sa pag-scan sa seguridad at pagpapanatili.
• I-scan ang mga Kahinaan sa Image: Gumamit ng mga tool tulad ng Trivy upang i-scan ang mga kilalang kahinaan sa mga image, at i-update ang mga image sa lalong madaling panahon.
• Gumamit ng Prinsipyo ng Pinakamababang Pribilehiyo: Iwasan ang pagpapatakbo ng mga container bilang root user.
• Limitahan ang mga Resource ng Container: Gumamit ng cgroups upang limitahan ang paggamit ng CPU at memorya ng container.
• Regular na I-update ang mga Image: Panatilihing napapanahon ang mga image upang ayusin ang mga kahinaan sa seguridad.
• Gumamit ng mga Tool sa Pag-scan ng Seguridad: Ang mga tool tulad ng Snyk, Clair, atbp. ay maaaring isama sa iyong proseso ng CI/CD upang awtomatikong i-scan ang mga kahinaan sa image.

KonklusyonAng artikulong ito ay nagbibigay ng mabilisang gabay sa pagsisimula sa Docker, na sumasaklaw sa mga pangunahing konsepto, hakbang sa pag-install, at isang simpleng halimbawa ng containerization ng Python application. Sa pamamagitan ng pag-aaral ng mga batayang kaalaman na ito, maaari kang magsimulang gumamit ng Docker upang bumuo, sumubok, at mag-deploy ng iyong mga application. Tandaan, mahalaga ang seguridad, at dapat mong palaging bigyang-pansin ang seguridad ng mga Docker image, at gumawa ng mga naaangkop na hakbang upang protektahan ang iyong mga application. Bagama't malakas ang Kubernetes sa malawakang container orchestration, ang Docker ay nananatiling isang simple at epektibong solusyon sa maraming sitwasyon. Sa pamamagitan ng pag-master ng Docker, mas mahusay mong mahaharap ang mga hamon ng modernong pagbuo at pag-deploy ng software.