Korzystanie z DockerFile do ujawnienia portów
W tym artykule pokażę ci, jak ujawniać porty za pomocą Dockerfile Z przykładem prawdziwego świata. Zacznijmy.
Tworzenie katalogu projektu:
Najpierw musimy utworzyć katalog projektu. W tym katalogu powinieneś zachować wszystkie pliki projektu i Dockerfile.
Uruchom następujące polecenie, aby utworzyć katalog projektu MyApp/ W katalogu domowym użytkowników i przejdź do niego:
$ mkdir ~/MyApp && cd ~/MyApp
Przygotowanie aplikacji internetowej:
Teraz utwórz katalog src/ w środku ~/MyApp/ Katalog z następującym poleceniem:
$ mkdir src
w src/ katalog, cały kod źródłowy mojej aplikacji Nodejs będzie przechowywany.
Po prostu stworzę prosty App.JS plik w src/ katalog i uruchom prosty serwer WWW na porcie 8080 Tylko do demonstracji.
SRC/App.JS Plik zawiera następujące wiersze kodów:
Pisanie Portów Docker Ports:
Teraz utwórz Dockerfile w ~/MyApp Katalog z następującym poleceniem:
$ Touch Dockerfile
Teraz wpisz następujące wiersze do Dockerfile i zachowaj to. Omówię, co oznaczają te linie później.
Tutaj, Od alpejskiego: 3.8 oznacza, użyj Alpine: 3.8 Zdjęcie dokera jako podstawy nowego obrazu, który będziemy z tego budować Dockerfile.
Uruchom aktualizację APK oznacza, uruchom Aktualizacja APK polecenie w obrazie Docker Base Alpine: 3.8.
Uruchom apk dodaj -No -cache nodejs oznacza, uruchom APK Dodaj polecenie instalacji języka programowania nodejs w Alpine: 3.8 Obraz podstawowy Docker.
KOPIUJ ./src /app oznacza, skopiuj wszystkie pliki z ~/MyApp/src katalog do /App katalog nowego obrazu dokera, który będziemy zbudować za pomocą Dockerfile.
Cmd [„/usr/bin/node”, „/app/app.JS ”] oznacza, uruchom /App/App.JS plik z nowego kontenera za pomocą węzeł binarny znajdujący się w /usr/bin/node.
Wreszcie do Expose 8080/TCP oznacza, odsłonić lub otwórz port TCP 8080 do komputera hosta.
Tworzenie niestandardowego obrazu Docker za pomocą DockerFile:
Teraz zróbmy niestandardowy obraz dokera Węzeł alpejski: v1 używając Dockerfile że właśnie stworzyliśmy.
Najpierw upewnij się, że jesteś w ~/MyApp/ Katalog, a następnie uruchom następujące polecenie, aby utworzyć niestandardowy obraz Docker Węzeł alpejski: v1:
$ Docker Build -t alpine -węzeł: v1 .
Jak widać, niestandardowy obraz dokera Węzeł alpejski: v1 jest tworzony. Wymagane podstawowe obraz i pakiety są pobierane z Internetu.
Jak widać, niestandardowy obraz dokera Węzeł alpejski: v1 jest utworzony pomyślnie.
Testowanie niestandardowego obrazu Docker:
Teraz możemy przetestować niestandardowy obraz dokera Węzeł alpejski: v1 bardzo łatwo. Wszystko, co musimy zrobić, to stworzyć pojemnik z Węzeł alpejski: v1 obraz.
Uruchom następujące polecenie, aby utworzyć kontener Docker www z Węzeł alpejski: v1 Obraz Docker:
$ Docker Run -d -it --name www alpine -węzeł: v1
Pojemnik www jest tworzone.
Teraz znajdźmy adres IP www Kontener dokera z następującym poleceniem:
$ Docker Inspect www | Adres GREP
Jak widać, w moim przypadku adres IP jest 172.17.0.3. Tak więc aplikacja Nodejs, którą napisałem, powinna być dostępna z przeglądarki internetowej w porcie 8080 tego adresu IP.
Voila! Mogę uzyskać dostęp do portu 8080 mojego www Kontener Docker.
Zasadniczo w ten sposób ujawniasz niektóre porty na niestandardowych obrazach Docker, które będziesz budować Dockerfile.
Odsłanianie portów TCP i UDP za pomocą DockerFile:
We wcześniejszej sekcji tego artykułu pokazałem, jak ujawnić port TCP za pomocą Dockerfile.
Możesz łatwo ujawnić port TCP (powiedzmy port TCP 53) w Twoim Dockerfile Z następującą linią:
Expose 53/TCP
Możesz także ujawnić port UDP (powiedzmy port UDP 53) z następującym wierszem w twoim Dockerfile:
Expose 53/UDP
Możesz wystawić port TCP i UDP w tym samym czasie z następującymi wierszami w swoim Dockerfile:
Expose 53/TCP
Expose 53/UDP
Jeśli nie określisz, jakiego protokołu (TCP lub UDP) użyć, TCP jest domyślnie używany. Na przykład, jeśli napiszesz następujący wiersz w swoim Dockerfile:
Expose 53
Następnie Docker założy, że chcesz użyć portu TCP 53.
Odsłanianie wielu portów za pomocą DockerFile:
Powiedzmy, że chcesz stworzyć niestandardowy obraz Docker Stack. W takim przypadku będziesz uruchomić serwer HTTP na niektórym porcie (powiedzmy port 80 lub 8080), serwer FTP, który działa na porcie TCP 21, serwerze bazy danych SQL (Say MySQL), który działa na porcie TCP 3306, lub serwer bazy danych NoSQL (powiedzmy MongoDB), który działa na porcie TCP 27017 lub 27018, serwerze SSH, który działa na porcie TCP 22. To dużo portów!
Dobra wiadomość jest taka; Możesz ujawnić tyle portów, ile potrzebuje na niestandardowym obrazie Docker utworzonym za pomocą za pomocą Dockerfile.
Porty w powyższym przykładzie mogą być ujawnione z następującymi wierszami w twoim Dockerfile:
Expose 80/TCP
Expose 8080/TCP
Expose 21/TCP
Expose 22/TCP
Expose 3306/TCP
Expose 27017/TCP
Expose 27018/TCP
Jeśli chcesz, możesz pozostawić specyfikację protokołu, ponieważ Docker domyślnie używa TCP i zrobić to samo z następującymi wierszami w swoim Dockerfile:
Expose 80
Expose 8080
Expose 21
Odsłaniaj 22
Expose 3306
Eksponuj 27017
Expose 27018
Jeśli potrzebujesz, możesz mieszać porty TCP i UDP w swoim Dockerfile. Na przykład, jeśli uruchomisz serwer DNS (który działa na porcie 53 UDP), wraz z powyższym przykładem, dodasz następujące wiersze do swojego Dockerfile.
Expose 80
Expose 8080
Expose 21
Odsłaniaj 22
Expose 53/UDP
Expose 3306
Eksponuj 27017
Expose 27018
Więc tak narażasz porty za pomocą Dockerfile. Nauczyć się więcej o Dockerfile i odsłanianie portów za pomocą Dockerfile, przeczytać Dockerfile Przewodnik referencyjny na https: // dokumentów.doker.com/silnik/reference/konstruktor/#expose
Dziękujemy za przeczytanie tego artykułu.