Wykorzystanie pamięci podręcznej kompilacji

Tworzenie obrazów Docker może zająć trochę czasu, szczególnie w przypadku złożonych aplikacji. Pamięć podręczna kompilowania Docker to inteligentna funkcja, która znacznie przyspiesza ten proces!

Działa poprzez ponowne używanie warstw z poprzednich kompilacji, dzięki czemu Docker nie musi za każdym razem tworzyć wszystkiego od podstaw.

Podczas tworzenia obrazu Docker za pomocą pliku Dockerfile Docker wykonuje każdą instrukcję wiersz po wierszu.

• Każda instrukcja, taka jak FROM, RUN lub COPY, tworzy nową „warstwę” obrazu.
• Warstwy te są nakładane jedna na drugą, tworząc obraz końcowy.

Przed wykonaniem instrukcji Docker sprawdza, czy wcześniej utworzył już dokładnie tę samą warstwę. Porównuje:

• Samą instrukcję (np. RUN apt update).
• „Kontekst” określonych instrukcji (np. pliki kopiowane za pomocą COPY).

Jeśli znajdzie pasującą warstwę, Docker ponownie używa jej z pamięci podręcznej zamiast ponownie wykonywać instrukcję.

Pamięć podręczna jest bardzo przydatna, ale nie zawsze jest używana. Jeśli Docker wykryje jakąkolwiek zmianę w instrukcji lub jej kontekście, unieważnia pamięć podręczną dla tej warstwy i wszystkich kolejnych warstw.

Oznacza to, że Docker rozpocznie tworzenie od tego miejsca, ignorując wszystkie zapisane w pamięci podręcznej warstwy znajdujące się niżej.

Aby maksymalnie zwiększyć liczbę trafień pamięci podręcznej, należy uporządkować instrukcje w pliku Dockerfile od tych, które najrzadziej się zmieniają, do tych, które zmieniają się najczęściej.

• Najpierw stabilne zależności: Należy zainstalować pakiety systemowe lub zależności aplikacji, które rzadko się zmieniają.
• Na końcu kod aplikacji: Kod źródłowy aplikacji, który często się zmienia, należy kopiować możliwie najpóźniej.

Spójrzmy na przykład. Umieszczając polecenie RUN pip install (które zazwyczaj zmienia się rzadziej) przed COPY . . (które zmienia się przy każdej aktualizacji kodu), Docker może ponownie używać warstwy zależności.

Załóżmy, że plik requirements.txt zawiera flask i gunicorn, a app.py jest główną aplikacją.

Dockerfile:

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app.py .
CMD ["python", "app.py"]

Jeśli zmieni się tylko app.py, Docker utworzy ponownie jedynie ostatnie warstwy COPY i CMD, oszczędzając czas!

Podczas używania COPY . . Docker sprawdza zmiany w każdym pliku kontekstu kompilowania. Nawet małe, nieistotne pliki (takie jak foldery .git lub lokalne dane testowe) mogą unieważnić pamięć podręczną.

Należy użyć pliku .dockerignore, aby wykluczyć niepotrzebne pliki i katalogi z kontekstu kompilowania. Dzięki temu nie będą one powodować unieważnienia pamięci podręcznej.

Umieść plik o nazwie .dockerignore w katalogu głównym kontekstu kompilowania (obok pliku Dockerfile).

Przykład pliku .dockerignore:

.git
.venv
__pycache__
*.log
node_modules

Od tej pory podczas wykonywania COPY . . Docker będzie ignorować te pliki, co zwiększy prawdopodobieństwo trafień pamięci podręcznej!

Czasami konieczne jest utworzenie wszystkiego od nowa z pominięciem całej pamięci podręcznej. Może to być przydatne podczas debugowania lub aby mieć pewność, że używane są absolutnie najnowsze wersje zależności.

Możesz wymusić ponowne utworzenie obrazu przez Docker bez używania pamięci podręcznej, dodając flagę --no-cache do polecenia kompilowania:

docker build --no-cache -t my-app:latest .

Tworzysz obraz Docker dla aplikacji Node.js. Obecny plik Dockerfile wygląda tak:

FROM node:16-alpine
WORKDIR /app
COPY . .
RUN npm install
CMD ["npm", "start"]

Jaka zmiana najlepiej zoptymalizuje ten plik Dockerfile pod kątem buforowania kompilowania?

Świetnie! Wiesz już, jak wykorzystywać pamięć podręczną kompilowania Docker do szybszego tworzenia obrazów.

• Docker tworzy obrazy warstwa po warstwie, ponownie używając zapisanych warstw, gdy jest to możliwe.
• Zmiana w instrukcji lub jej kontekście unieważnia pamięć podręczną od tego miejsca.
• Aby zoptymalizować proces, uporządkuj instrukcje od tych, które najrzadziej się zmieniają, do tych, które zmieniają się najczęściej.
• Używaj .dockerignore, aby wykluczać nieistotne pliki z kontekstu kompilowania.
• W razie potrzeby użyj --no-cache, aby wymusić utworzenie obrazu od nowa.

Wydajne buforowanie przyspiesza cykle tworzenia aplikacji i umożliwia sprawniejsze wdrażanie!