Jak mogę dołączyć pliki spoza kontekstu kompilacji Dockera za pomocą polecenia „DODAJ” w pliku Dockera?

Z dokumentacji dokera:

Ścieżka musi znajdować się w kontekście kompilacji; nie można DODAĆ ../something/something, ponieważ pierwszym krokiem kompilacji dokera jest wysłanie katalogu kontekstowego (i podkatalogów) do demona dokera.

Nie chcę zrestrukturyzować całego mojego projektu tylko po to, by uwzględnić Dockera w tej sprawie. Chcę przechowywać wszystkie moje pliki Docker w tym samym podkatalogu.

Wygląda również na to, że Docker jeszcze nie obsługuje (i może nigdy nie obsługuje) dowiązań symbolicznych: polecenie Dockerfile ADD nie podąża za dowiązaniami symbolicznymi na hoście # 1676.

Jedyną rzeczą, o której mogę pomyśleć, jest krok poprzedzający kompilację, aby skopiować pliki do kontekstu kompilacji Dockera (i skonfigurować kontrolę wersji, aby ignorowała te pliki). Czy istnieje lepsze obejście tego problemu?

Najlepszym sposobem obejścia tego problemu jest określenie pliku Docker niezależnie od kontekstu kompilacji za pomocą opcji -f.

Na przykład to polecenie zapewni dostęp do polecenia ADD do dowolnego elementu w bieżącym katalogu.

docker build -f docker-files/Dockerfile .

Aktualizacja : Docker pozwala teraz mieć plik Docker poza kontekstem kompilacji (naprawiony w 18.03.0-ce, https://github.com/docker/cli/pull/886 ). Możesz także zrobić coś takiego

docker build -f ../Dockerfile .

Często używam tej --build-argopcji do tego celu. Na przykład po umieszczeniu następującego pliku w Dockerfile:

ARG SSH_KEY
RUN echo "$SSH_KEY" > /root/.ssh/id_rsa

Możesz po prostu zrobić:

docker build -t some-app --build-arg SSH_KEY="$(cat ~/file/outside/build/context/id_rsa)" .

Zwróć jednak uwagę na następujące ostrzeżenie z dokumentacji Docker :

Ostrzeżenie: Nie zaleca się używania zmiennych czasu kompilacji do przekazywania sekretów, takich jak klucze github, poświadczenia użytkownika itp. Wartości zmiennych kompilacji są widoczne dla każdego użytkownika obrazu za pomocą polecenia historii dokera.

W systemie Linux możesz montować inne katalogi zamiast ich symbolicznie

mount --bind olddir newdir

Aby uzyskać więcej informacji, zobacz /superuser/842642

Nie wiem, czy coś podobnego jest dostępne dla innych systemów operacyjnych. Próbowałem też przy użyciu Samby udostępnić folder i ponownie zainstalować go w kontekście Dockera, który również działał.

Spędziłem dobry czas, próbując znaleźć dobry wzór i jak lepiej wyjaśnić, co się dzieje z tą obsługą funkcji. Uświadomiłem sobie, że najlepszym sposobem na wyjaśnienie tego jest ...

• Plik Docker: będzie widział pliki tylko pod własną ścieżką względną
• Kontekst: miejsce w „przestrzeni”, w którym pliki, które chcesz udostępnić i plik Docker zostaną skopiowane

Tak więc powiedziawszy, oto przykład Dockerfile, który musi ponownie użyć pliku o nazwie start.sh

Plik Docker

To ALWAYSbędzie ładować z jego względnej ścieżki, posiadające aktualną dir samego siebie jako localodniesienie do ścieżek można określić.

COPY start.sh /runtime/start.sh

Akta

Biorąc pod uwagę ten pomysł, możemy pomyśleć o posiadaniu wielu kopii pliku Docker, który tworzy określone rzeczy, ale wszystkie one potrzebują dostępu do start.sh.

./all-services/
   /start.sh
   /service-X/Dockerfile
   /service-Y/Dockerfile
   /service-Z/Dockerfile
./docker-compose.yaml

Biorąc pod uwagę tę strukturę i powyższe pliki, oto docker-compose.yml

docker-compose.yaml

• W tym przykładzie katalogiem sharedkontekstowym jest runtimekatalog.
  • Ten sam model mentalny tutaj, pomyśl, że wszystkie pliki w tym katalogu są przeniesione do tzw context.
  • Podobnie, po prostu określ plik Docker, który chcesz skopiować do tego samego katalogu. Możesz to określić za pomocą dockerfile.
• katalog, w którym znajduje się główna zawartość, to kontekst, który należy ustawić.

docker-compose.ymlJest następujący

version: "3.3"
services:

  service-A
    build:
      context: ./all-service
      dockerfile: ./service-A/Dockerfile

  service-B
    build:
      context: ./all-service
      dockerfile: ./service-B/Dockerfile

  service-C
    build:
      context: ./all-service
      dockerfile: ./service-C/Dockerfile

• all-servicejest ustawiony jako kontekst, plik współdzielony start.shjest tam kopiowany, a także plik Docker określony przez każdy z nich dockerfile.
• Każdy zostanie zbudowany na swój własny sposób, udostępniając plik startowy!

Twoje zdrowie!

Jeśli przeczytasz dyskusję w numerze 2745, nie tylko doker może nigdy nie obsługiwać dowiązań symbolicznych, ale nigdy nie może obsługiwać dodawania plików poza twoim kontekstem. Wydaje się, że filozofią projektu jest to, że pliki, które wchodzą do kompilacji dokera, powinny jawnie stanowić część kontekstu lub pochodzić z adresu URL, w którym prawdopodobnie są wdrażane również w wersji stałej, aby kompilacja była powtarzalna przy dobrze znanych adresach URL lub plikach dostarczanych z pojemnik dokera.

Wolę budować ze źródła kontrolowanego wersją - tj. Kompilacja dokera -t rzeczy http://my.git.org/repo - w przeciwnym razie buduję z przypadkowego miejsca z losowymi plikami.

zasadniczo nie .... - SvenDowideit, Docker Inc

Tylko moja opinia, ale myślę, że powinieneś dokonać restrukturyzacji, aby oddzielić kod i repozytoria dokerów. W ten sposób kontenery mogą być ogólne i pobierać dowolną wersję kodu w czasie wykonywania, a nie w czasie kompilacji.

Alternatywnie, użyj Dockera jako podstawowego artefaktu wdrażania kodu, a następnie umieść plik Dockera w katalogu głównym repozytorium kodu. jeśli wybierzesz tę trasę, prawdopodobnie warto mieć nadrzędny kontener dokujący, aby uzyskać bardziej ogólne szczegóły na poziomie systemu, i kontener podrzędny, aby skonfigurować specyficzne dla kodu.

Uważam, że prostszym obejściem jest zmiana samego „kontekstu”.

Na przykład zamiast dawać:

docker build -t hello-demo-app .

który ustawia bieżący katalog jako kontekst, powiedzmy, że chcesz katalog macierzysty jako kontekst, po prostu użyj:

docker build -t hello-demo-app ..

Możesz także utworzyć archiwum tego, czego obraz potrzebuje najpierw i użyć go jako kontekstu.

https://docs.docker.com/engine/reference/commandline/build/#/tarball-contexts

Korzystając z docker-compose, osiągnąłem to, tworząc usługę, która montuje potrzebne mi woluminy i zatwierdzając obraz kontenera. Następnie w kolejnej usłudze polegam na wcześniej zatwierdzonym obrazie, który zawiera wszystkie dane przechowywane w zamontowanych lokalizacjach. Będziesz wtedy musiał skopiować te pliki do ich ostatecznego miejsca docelowego, ponieważ katalogi montowane na hoście nie są zatwierdzane podczas uruchamiania docker commitpolecenia

Aby to osiągnąć, nie musisz używać kompilatora dokerów, ale ułatwia to życie

# docker-compose.yml

version: '3'
  services:
    stage:
      image: alpine
      volumes:
        - /host/machine/path:/tmp/container/path
      command: bash -c "cp -r /tmp/container/path /final/container/path"
    setup:
      image: stage

# setup.sh

# Start "stage" service
docker-compose up stage

# Commit changes to an image named "stage"
docker commit $(docker-compose ps -q stage) stage

# Start setup service off of stage image
docker-compose up setup

Miałem ten sam problem z projektem i niektórymi plikami danych, których nie mogłem przenieść w kontekście repozytorium z powodów HIPPA. Skończyło się na 2 plikach Docker. Jeden buduje główną aplikację bez potrzebnych mi elementów poza kontenerem i publikuje ją w wewnętrznym repozytorium. Następnie drugi plik dokera pobiera ten obraz i dodaje dane i tworzy nowy obraz, który jest następnie wdrażany i nigdy nigdzie nie przechowywany. Nie jest to idealne, ale zadziałało w moich celach, aby ukryć poufne informacje poza repozytorium.

Łatwym obejściem może być po prostu zamontowanie woluminu (za pomocą flagi -v lub --mount) po uruchomieniu go i dostęp do plików w ten sposób.

przykład:

docker run -v /path/to/file/on/host:/desired/path/to/file/in/container/ image_name

więcej informacji: https://docs.docker.com/storage/volumes/

Jak opisano w tym problemie GitHub, kompilacja faktycznie się dzieje /tmp/docker-12345, więc względna ścieżka podobna ../relative-add/some-filedo /tmp/docker-12345. W ten sposób szukałby /tmp/relative-add/some-file, co jest również wyświetlane w komunikacie o błędzie. *

Dołączanie plików spoza katalogu kompilacji jest niedozwolone, więc powoduje to wyświetlenie komunikatu „Zakazana ścieżka”.

Jednym szybkim i brudnym sposobem jest ustawienie kontekstu kompilacji na tyle poziomów, ile potrzebujesz - ale może to mieć konsekwencje. Jeśli pracujesz w architekturze mikrousług, która wygląda następująco:

./Code/Repo1
./Code/Repo2
...

Możesz ustawić kontekst kompilacji na Codekatalog nadrzędny, a następnie uzyskać dostęp do wszystkiego, ale okazuje się, że przy dużej liczbie repozytoriów może to spowodować długi czas kompilacji.

Przykładem może być sytuacja, w której inny zespół utrzymuje schemat bazy danych, Repo1a kod twojego zespołu Repo2zależy od tego. Chcesz dokować tę zależność przy pomocy niektórych własnych danych źródłowych, nie martwiąc się o zmiany schematu lub zanieczyszczenie repozytorium drugiego zespołu (oczywiście w zależności od tego, jakie zmiany mogą być konieczne, musisz zmienić skrypty danych źródłowych). Drugie podejście jest zuchwałe, ale omija kwestię długich wersji:

Utwórz skrypt sh (lub ps1), ./Code/Repo2aby skopiować potrzebne pliki i wywołać żądane polecenia dokera, na przykład:

#!/bin/bash
rm -r ./db/schema
mkdir ./db/schema

cp  -r ../Repo1/db/schema ./db/schema

docker-compose -f docker-compose.yml down
docker container prune -f
docker-compose -f docker-compose.yml up --build

W pliku skompilowania dokera po prostu ustaw kontekst jako Repo2root i użyj zawartości ./db/schemakatalogu w pliku dokera, nie martwiąc się o ścieżkę. Pamiętaj, że ryzykujesz przypadkowym przekazaniem tego katalogu do kontroli źródła, ale akcje czyszczenia skryptów powinny być dość łatwe.

W moim przypadku mój plik Docker jest zapisany jak szablon zawierający symbole zastępcze, które zastępuję rzeczywistą wartością za pomocą mojego pliku konfiguracyjnego.

Nie mogłem więc bezpośrednio określić tego pliku, ale potokować go w kompilacji dokera w następujący sposób:

sed "s/%email_address%/$EMAIL_ADDRESS/;" ./Dockerfile | docker build -t katzda/bookings:latest . -f -;

Ale z powodu potoku COPYpolecenie nie działało. Ale powyższy sposób rozwiązuje to przez -f -(jawnie mówiąc, plik nie został dostarczony). Wykonując tylko -bez -fflagi, kontekst ORAZ plik Docker nie są udostępniane, co stanowi zastrzeżenie.

Sztuką jest rozpoznanie, że możesz określić kontekst w komendzie kompilacji, aby dołączyć pliki z katalogu nadrzędnego, jeśli podasz ścieżkę Dockera, zmieniłbym mój plik Docker tak, aby wyglądał następująco:

...
COPY ./ /dest/
...

Wtedy moje polecenie kompilacji może wyglądać następująco:

docker built -t TAG -f DOCKER_FILE_PATH CONTEXT

Z katalogu projektu

docker built -t username/project[:tag] -f ./docker/Dockerfile .

Z projektu / dokera

docker built -t username/project[:tag] -f ./docker/Dockerfile ..