Dockerfile kwa Ubuntu: Mwongozo Kamili wa Msingi hadi Juu kwa Ujenzi wa Picha za Docker

1. Utangulizi

Docker na Dockerfile ni nini?

Katika miaka ya hivi karibuni, Docker imepata umaarufu haraka kama njia bora ya kurahisisha mazingira ya maendeleo na kupeleka programu. Docker inafunga programu na utegemezi wao katika kitengo kimoja kinachoitwa “kontena,” ikiruhusu zifanye kazi kwa uthabiti katika mazingira tofauti.

Ili kujenga kontena hizi za Docker, muundo unaoitwa Dockerfile unahitajika. Dockerfile ni faili ya maandishi inayofafanua picha ya mfumo wa uendeshaji msingi, programu iliyosakinishwa, anuwai za mazingira, na maelezo mengine ya usanidi. Watengenezaji programu wanaweza kuitumia kujenga mazingira yaliyobadilishwa kiotomatiki.

Kwa nini Tumia Ubuntu kama Picha Msingi?

Unapounda Dockerfile, hatua ya kwanza ni kuchagua picha ya mfumo wa uendeshaji msingi. Miongoni mwa chaguzi nyingi zinazopatikana, Ubuntu ni moja ya maarufu zaidi. Ubuntu ni usambazaji wa Linux unaotegemea Debian unaojulikana kwa urahisi wake wa matumizi na usanidi wa mazingira yanayobadilika unaoungwa mkono na mfumo mkubwa wa pakiti.

Dockerfile zinazotegemea Ubuntu hutoa faida kadhaa:

• Hati rasmi na za jamii nyingi, zinazosababisha kawaida ndogo ya kujifunza
• Uwekezaji rahisi wa pakiti na zana kwa kutumia APT
• Picha rasmi nyepesi na ndogo (kama vile ubuntu:20.04 na ubuntu:24.04 )

Kusudi la Makala Hii na Watazamaji Wanaolengwa

Makala hii inalenga neno la msingi “Dockerfile Ubuntu” na inaeleza jinsi ya kuunda Dockerfile zinazotegemea Ubuntu kwa njia rahisi kwa wanaoanza kuelewa.

Inashughulikia kila kitu kutoka muundo msingi wa Dockerfile hadi maelekezo ya hatua kwa hatua ya kujenga mazingira ya Ubuntu, mifano ya kuweka mazingira ya programu kama Python, na makosa ya kawaida na suluhu zao.

Makala hii inapendekezwa kwa:

• Wale wanaotaka kujenga mazingira kwa kutumia Dockerfile kwa mara ya kwanza
• Watengenezaji programu wanaotaka kuunda mazingira ya maendeleo yanayoweza kurejelewa kwenye Ubuntu
• Yeyote anayetaka kuongeza uelewa wao, pamoja na mbinu za kutatua matatizo

2. Muundo Msingi wa Dockerfile

Dockerfile ni nini na Jukumu Lake ni nini?

Dockerfile ni kama mapishi ya kuunda picha za Docker. Inafafanua ni mfumo wa uendeshaji msingi gani utumie, programu gani usakinishe, na jinsi ya kuweka mazingira.

Kwa kuendesha amri ya docker build kulingana na faili hii, unaweza kuunda mazingira ya maendeleo na wakati wa utendaji yanayoweza kurejelewa kwa urahisi.

Faida za kutumia Dockerfile:

• Usanidi wa mazingira kiotomatiki (hakuna haja ya kurudia kwa mkono)
• Huondoa kutofautiana kwa mazingira katika maendeleo ya timu
• Uingizaji rahisi katika mifereji ya CI/CD

Maelekezo ya Kawaida Yanayotumiwa katika Dockerfile

Dockerfile inajumuisha maelekezo (maagizo) mengi. Yafuatayo ni baadhi ya yanayotumiwa sana. Kwa kuzichanganya kwa usahihi, unaweza kujenga Dockerfile inayotegemea Ubuntu.

Mfano Mdogo wa Dockerfile Inayotegemea Ubuntu

Yafuatayo ni mfano wa msingi sana wa Dockerfile inayotumia Ubuntu kama picha msingi.

FROM ubuntu:24.04

RUN apt-get update && apt-get install -y \
    curl \
    vim

CMD ["/bin/bash"]

Dockerfile hii inatumia Ubuntu 24.04 kama picha msingi, inasakinisha zana za curl na vim, na inaanza ganda la Bash wakati kontena inaanza.

Kuchagua Lebo Sahihi ya Ubuntu

Picha za Docker za Ubuntu zimechapishwa katika kumbukumbu rasmi ya Docker Hub. Wakati kutaja ubuntu:latest kutatumia toleo la hivi karibuni, kubainisha toleo kwa uwazi kunapendekezwa.

Kwa mfano:

• ubuntu:22.04 (LTS: Msaada wa Muda Mrefu, inayolenga uthabiti)
• ubuntu:24.04 (LTS ya hivi karibuni, inayolenga vipengele vipya)

Chagua toleo kulingana na kama uthabiti au vipengele vipya ndio kipaumbele chako.

3. Vitendo: Kuunda Dockerfile Inayotegemea Ubuntu

Kusakinisha Pakiti Zinazohitajika katika Mazingira ya Ubuntu

When building an Ubuntu environment using a Dockerfile, it is often necessary to install additional packages. For example, the following utilities are commonly used when setting up a development environment:

• curl : For downloading files and testing APIs
• vim : A lightweight text editor
• git : Version control system
• build-essential : Essential tools for building C/C++ programs

To install these packages in a Dockerfile, use the RUN instruction.

FROM ubuntu:24.04

RUN apt-get update && apt-get install -y \
    curl \
    vim \
    git \
    build-essential

By running apt-get update first, you ensure that the latest package lists are retrieved before installation.

Configuring Non-Interactive Installation

On Ubuntu, apt-get install may sometimes require user input. However, interactive operations are not possible during Docker builds. To avoid this, it is recommended to set an environment variable and enable non-interactive mode.

ENV DEBIAN_FRONTEND=noninteractive

This suppresses prompts such as locale or timezone selection and allows installations to proceed smoothly.

Reducing Image Size by Removing Unnecessary Cache

When using APT, downloaded temporary files (cache) may remain in the image, increasing its final size. You can reduce the image size by removing the cache as shown below:

RUN apt-get update && apt-get install -y \
    curl \
    vim \
    && rm -rf /var/lib/apt/lists/*

Combining multiple commands into a single RUN instruction also helps prevent unnecessary increases in image layers.

Best Practices for Writing Dockerfiles

In real‑world development environments, the following Dockerfile best practices are widely recommended:

• Combine RUN instructions whenever possible to reduce the number of layers
• Explicitly define versions and settings using ENV
• Use comments to clearly describe the purpose of each step
• Avoid leaving unnecessary files by using rm and --no-install-recommends

Example:

RUN apt-get update && apt-get install -y --no-install-recommends \
    curl \
    git \
    && rm -rf /var/lib/apt/lists/*

This approach results in a lighter and more maintainable Dockerfile.

4. Building and Verifying Docker Images

Building a Docker Image from a Dockerfile

Once your Dockerfile is ready, the next step is to build a Docker image. This is done using the docker build command. Run the following command in the directory containing your Dockerfile:

docker build -t my-ubuntu-image .

• The -t option assigns a name (tag) to the image. In this example, the image is named my-ubuntu-image.
• The dot (.) refers to the current directory containing the Dockerfile.

Docker will read the instructions in the Dockerfile sequentially and build the image accordingly.

Checking the Built Docker Image

After the image has been built successfully, you can verify it using the following command:

docker images

This displays a list of Docker images stored locally, including the following information:

• REPOSITORY (image name)
• TAG
• IMAGE ID (unique identifier)
• CREATED (creation date)
• SIZE

Example:

REPOSITORY        TAG       IMAGE ID       CREATED          SIZE
my-ubuntu-image   latest    abcd1234abcd   5 minutes ago    189MB

This confirms that the image has been registered correctly.

Running a Docker Container for Verification

To verify that the created image works as expected, start a Docker container using the following command:

docker run -it my-ubuntu-image

• The -it option launches an interactive terminal session.
• If successful, a Bash prompt will appear, indicating that you are inside the Ubuntu container.

Inside the container, you can verify installed tools with commands such as:

curl --version
vim --version

.

Ikiwa amri hizi zinafanya kazi kwa usahihi, Dockerfile yako imewekwa vizuri.

Kusafisha Picha na Kontena Zisizotumika

Ujenzi wa mara kwa mara na majaribio yanaweza kuacha picha za Docker na kontena zisizotumika kwenye mfumo wako. Inashauriwa kuzifuta mara kwa mara kwa kutumia amri zifuatazo:

• Ondoa kontena zilizostahimishwa:

  docker container prune
  

• Ondoa picha zisizotumika:

  docker image prune
  

• Ondoa data zote zisizotumika (tumia kwa tahadhari):

  docker system prune
  

Operesheni hizi husaidia kuokoa nafasi kwenye diski na kuzuia matatizo yanayoweza kutokea.

5. Juu ya Kiwango: Kujenga Mazingira ya Python

Kuwezesha Python katika Dockerfile ya Ubuntu

Unapojenga mazingira ya Ubuntu kwa kutumia Dockerfile, kuongeza mazingira ya utekelezaji wa Python humruhusu matumizi mengi, ikijumuisha maendeleo, upimaji, na ujifunzaji wa mashine. Ingawa Python inaweza tayari kuwa imewekwa kwenye Ubuntu kwa chaguo-msingi, ni kawaida kuibainisha wazi ili kudhibiti toleo na usimamizi wa vifurushi vizuri zaidi.

Kufunga Python kwa kutumia APT

Njia rahisi zaidi ni kufunga Python kwa kutumia vifurushi vya APT. Hapa chini ni mfano:

FROM ubuntu:24.04

RUN apt-get update && apt-get install -y \
    python3 \
    python3-pip \
    && rm -rf /var/lib/apt/lists/*

Njia hii inatoa toleo la Python thabiti la mfumo (kama Python 3.10 au 3.12, kulingana na toleo la Ubuntu). Unaweza pia kufunga vifurushi vya ziada vya Python kwa kutumia amri ya pip.

Kusimamia Matoleo ya Python kwa pyenv

Ukihitaji toleo maalum la Python au unataka kubadilisha kati ya matoleo mengi, kutumia pyenv inashauriwa sana.

Mfano ufuatao unaonyesha jinsi ya kufunga Python 3.11.6 kwa kutumia pyenv katika Dockerfile:

FROM ubuntu:24.04

ENV DEBIAN_FRONTEND=noninteractive

RUN apt-get update && apt-get install -y \
    git \
    curl \
    make \
    build-essential \
    libssl-dev \
    zlib1g-dev \
    libbz2-dev \
    libreadline-dev \
    libsqlite3-dev \
    wget \
    llvm \
    libncurses5-dev \
    libncursesw5-dev \
    xz-utils \
    tk-dev \
    libffi-dev \
    liblzma-dev \
    && rm -rf /var/lib/apt/lists/*

# Install pyenv
RUN git clone https://github.com/pyenv/pyenv.git ~/.pyenv

ENV PYENV_ROOT="$HOME/.pyenv"
ENV PATH="$PYENV_ROOT/bin:$PATH"

RUN echo 'eval "$(pyenv init --path)"' >> ~/.bashrc

# Install a specific Python version
RUN pyenv install 3.11.6 && pyenv global 3.11.6

Mpangilio huu unatoa mazingira ya Python yanayobadilika na yanayodhibitiwa vizuri.

Kusimamia Paketi kwa kutumia requirements.txt

Miradi mingi ya ulimwengu halisi inahitaji maktaba nyingi za Python. Mategemeo haya kawaida husimamiwa kwa kutumia faili la requirements.txt.

Kwanza, unda faili la requirements.txt katika mzizi wa mradi wako:

flask==2.3.2
requests>=2.25.1
pandas

Kisha rejelea katika Dockerfile yako kama ifuatavyo:

COPY requirements.txt /app/requirements.txt
WORKDIR /app

RUN pip install --no-cache-dir -r requirements.txt

Hii inaruhusu maktaba yote yanayohitajika kusakinishwa mara moja na kuboresha sana urejeshaji wa mazingira.

Mazoea Mazuri

• Unapotumia Python, kuunda mazingira ya pepe (virtualenv au venv) husaidia kuzuia migogoro ya utegemezi.
• Kutumia chaguo za kupunguza kashe kama --no-cache-dir hupunguza ukubwa wa picha ya Docker.
• Kuendesha pip install --upgrade pip kabla ya kusakinisha vifurushi kunaweza kusaidia kuepuka makosa ya usakinishaji.

6. Masuala ya Kawaida na Utatuzi wa Tatizo

Makosa ya Ruhusa

Mfano:

Permission denied

Kosa hili hutokea wakati faili zilizokopiwa hazina ruhusa za kutekeleza au wakati umiliki wa faili na watumiaji wa utekelezaji hawajasanidiwa sahihi.

Suluhisho:

• Fanya faili iwe na ruhusa ya kutekeleza:

  RUN chmod +x script.sh
  

• Badilisha umiliki wa faili ikiwa inahitajika:

  RUN chown root:root /path/to/file
  

Kifurushi Hakijapatikana au Kushindwa kwa Usakinishaji

Mfano:

E: Unable to locate package xxx

.

This error typically occurs when apt-get update has not been executed or when the package name is incorrect.

Solution:

• Always run apt-get update before installing packages:

  RUN apt-get update && apt-get install -y curl
  

• Verify package names and check for typos

Network-Related Errors

Example:

Temporary failure resolving 'deb.debian.org'

This error indicates a DNS resolution issue during the build process.

Solution:

• Restarting the Docker daemon may resolve the issue:

  sudo systemctl restart docker
  

• Review Docker DNS settings by adding DNS servers in /etc/docker/daemon.json :

  {
    "dns": ["8.8.8.8", "8.8.4.4"]
  }
  

Build Using Outdated Cache

Docker uses layer-based caching to speed up builds. As a result, changes to a Dockerfile may not always be reflected immediately.

Solution:

• Rebuild without cache:

  docker build --no-cache -t my-image .
  

Container Exits Immediately or Startup Command Does Not Run

Causes:

• The command specified in CMD or ENTRYPOINT contains an error
• Using CMD ["/bin/bash"] without interactive mode causes immediate exit

Solution:

• Start the container in debug mode:

  docker run -it my-image /bin/bash
  

• Understand the differences between CMD and ENTRYPOINT and use them appropriately

By encountering and resolving these issues, your Dockerfile design skills will steadily improve. When errors occur, carefully read the error messages and identify which instruction and layer caused the problem.

7. Summary

Key Takeaways for Creating Ubuntu-Based Dockerfiles

This article provided a step-by-step explanation of how to build Ubuntu environments using Dockerfiles, covering both fundamental and advanced topics. Let’s review the key points:

• Understanding Dockerfile fundamentals is the first step Instructions such as FROM , RUN , CMD , and ENV enable automated environment creation.
• Ubuntu is a stable and flexible base image Its extensive package ecosystem, large user base, and LTS releases make it ideal for development environments.
• Practical package management allows installation of necessary tools and libraries Proper use of apt-get , cache cleanup, and non-interactive installation is essential.
• Building practical environments such as Python is fully supported by Dockerfiles Tools like pyenv , pip , and requirements.txt ensure reproducible setups.
• Troubleshooting skills directly impact stable operations Understanding permissions, networking, and build cache behavior significantly improves productivity.

Next Steps in Dockerfile Learning

Once you are comfortable using Dockerfiles, you can extend your skills beyond development into testing and production deployments. Consider exploring the following topics:

• Managing multi-container setups with Docker Compose
• Integrating with CI/CD tools such as GitHub Actions and GitLab CI
• Working with container orchestration platforms like Kubernetes

Official Documentation and Reference Links

• Docker Official Documentation (Japanese)
• Docker Hub – Official Ubuntu Images
• pyenv GitHub Repository

8. FAQ (Frequently Asked Questions)

Q1. Which Ubuntu version should I choose in a Dockerfile?

A1. In most cases, choosing an LTS (Long Term Support) release is recommended for stability and long-term maintenance. Versions such as ubuntu:22.04 and ubuntu:20.04 are widely used and supported for five years.

If you need the latest packages or language versions, you may choose a newer release such as ubuntu:24.04, but thorough testing is recommended.

Q2. Why does apt-get install report “package not found”?

A2. Sababu ya kawaida zaidi ni kushindwa kuendesha apt-get update kabla. Bila kusasisha orodha ya paketi, APT haiwezi kupata paketi zilizoomwa.

Mfano sahihi:

RUN apt-get update && apt-get install -y curl

Pia hakikisha kuwa majina ya paketi ni sahihi na hayajapunguzwa (kwa mfano, tumia python3 badala ya python).

Q3. Ninawezaje kuweka vigeuza vya mazingira katika Dockerfile?

A3. Tumia maagizo ya ENV kufafanua vigeuza vya mazingira vinavyopatikana wakati wa kujenga na wakati wa kuendesha kontena.

Mfano:

ENV DEBIAN_FRONTEND=noninteractive

Hii hutumiwa kwa kawaida kuzuia ombi la kuingiliana wakati wa usakinishaji wa APT. Vigeuza vya mazingira pia ni muhimu kwa usanidi wa programu na funguo za API.

Q4. Tofauti gani kati ya CMD na ENTRYPOINT?

A4. Zote zinaelezea amri zinazotekelezwa wakati kontena inaanza, lakini tabia zao zinatofautiana.

Mfano:

CMD ["python3", "app.py"]
# vs
ENTRYPOINT ["python3"]
CMD ["app.py"]

Katika kesi ya pili, unaweza kupitisha hoja kwa kutumia docker run my-image another_script.py.

Q5. Kwa nini mabadiliko yangu ya Dockerfile hayajaonekana?

A5. Docker hutumia kache ya kujenga, ambayo inaweza kusababisha tabaka zisizobadilika kutumika tena hata baada ya kuhariri Dockerfile.

Suluhisho:

docker build --no-cache -t my-image .

Hii inalazimisha kujenga upya kamili na inahakikisha mabadiliko yote yanatumika.