Port forwarding i Docker är en process som gör att vi kan exponera containerporten på Docker-värdsystemet. Det tillåter oss att köra applikationen i en isolerad miljö och även göra den tillgänglig från utsidan av behållaren på en användardator.
Det här inlägget kommer att visa:
- Hur man vidarebefordrar port i Docker med '-p' eller '–publish'-tagg
- Hur man vidarebefordrar port i Docker med Docker Compose
- Hur man vidarebefordrar port till ett specifikt nätverk
- Slutsats
Hur man vidarebefordrar port i Docker med '-p' eller '–publish' Tag
För att vidarebefordra en port i Docker måste användaren publicera containerporten på Docker-värden. För detta ändamål, kör behållaren på docker-värden med hjälp av ' -s ' eller ' -publicera ' taggen i ' hamnarkörning ” kommando.
För korrekt demonstration, följ instruktionerna nedan.
Steg 1: Skapa Dockerfile
Skapa först en fil och ställ in dess namn som ' Dockerfil ”. Den här filen innehåller textinstruktionerna för att skapa mallen för Docker-behållaren. Till exempel, låt oss dockerisera det enkla Golang-programmet med hjälp av nedanstående utdrag i Dockerfilen:
FRÅN golang: 1.8
WORKDIR / gå / src / app
COPY main2.go .
KÖR och bygg -O webbserver .
ÖVERSIKT 8080
CMD [ './webbserver' ]
I det givna utdraget:
- ' FRÅN ” kommandot används för att ställa in basbilden.
- ' WORKDIR ” definierar behållarens arbetskatalog.
- ' KOPIERA ” kommandot kommer att skapa en kopia av programfilen i den containerspecificerade sökvägen.
- ' SPRINGA ” kommandot kommer att utföra det angivna kommandot i behållaren.
- ' ÖVERSIKT ” kommandot anger porten där behållaren kommer att lyssnas på.
- ' CMD ” anger de körbara punkterna för behållaren.
Steg 2: Skapa ett Golang-program
Skapa sedan en annan fil med namnet ' main2.go ' och klistra in nedanstående Golang-program som skriver ut en enkel sträng på port ' 8080 ”:
huvudpaketet
importera (
'fmt'
'logga'
'net/http'
)
funktionshanterare ( I http.ResponseWriter, r * http.Begäran ) {
html := `
DOCTYPE html >
< html >
< huvud >
< titel > Hej Golang ! titel >
< stil >
kropp {
bakgrundsfärg: #D2B48C;
}
.behållare {
text-align: center;
stoppning: 50px;
}
stil >
huvud >
< kropp >
< div klass = 'behållare' >
< h1 > Hallå ! Välkommen till LinuxHint Tutorial h1 >
div >
kropp >
html >`
w.Header ( ) .Uppsättning ( 'Innehållstyp' , 'text/html' )
fmt.Fprint ( I , html )
}
func huvud ( ) {
http.HandleFunc ( '/' , hanterare )
log.Dödlig ( http.ListenAndServe ( '0.0.0.0:8080' , noll ) )
}
Steg 3: Generera containerns ögonblicksbild
Generera nu en ögonblicksbild för behållaren från ovan angivna Dockerfile. För detta ändamål, navigera först till katalogen där Dockerfilen skapas med hjälp av ' cd
Skapa sedan den nya behållarbilden med det givna kommandot:
hamnarbyggare -t golang-img . 
Det givna resultatet visar att bilden skapas enligt det angivna byggkontexten.
Steg 4: Vidarebefordra värdporten till containerporten
Kör nu containern och vidarebefordra värdporten till containerporten för att komma åt dockerize-appen utanför containern på en lokal maskin. För detta ändamål, kör 'docker run –namn
Här, ' -s flaggan används för att publicera containerexekveringsporten på dockningsvärden:
Steg 5: Verifiering
För verifiering, se de körande behållarna med ' hamnare ps ”:
hamnarbetare psI resultatet nedan lyssnar den containeriserade applikationen på tillgängliga nätverksgränssnitt ' 0.0.0.0 ' på publicerad port ' 8080 ”. Det innebär att porten vidarebefordras till det program som körs på värddatorn:
Starta nu webbläsaren och navigera till ' http://localhost:8080/ ” och verifiera om portvidarebefordranstekniken tillämpas eller inte och om den containeriserade applikationen är tillgänglig utanför containern på värdsystemet:
Här har vi framgångsrikt vidarebefordrat värdporten till containerporten och applikationen är tillgänglig på dockarvärden.
Hur man vidarebefordrar port i Docker med Docker Compose
För att vidarebefordra containerporten till värden för att komma åt den containeriserade applikationen från utsidan av containern, kan användaren använda ' hamn ” tangenten i compose yaml-filen. Docker compose är en Docker-tjänst som gör att vi kan köra olika tjänster och applikationer i olika containrar. Använda ' docker-compose.yml ”-fil kan användaren även vidarebefordra containerporten till värddatorn och ha en applikationsanslutning till omvärlden.
Kolla in proceduren nedan för illustrationer.
Steg 1: Skapa skrivfil
Skapa först en fil med namnet ' docker-compose.yml ”-filen och lägg till följande innehåll i filen:
version: '3'tjänster:
webb:
bygga:.
hamnar:
- 8080 : 8080
I utdraget ovan, ' hamnar ”-tangenten används för att ansluta värden till containerporten. Här är det första värdet värdporten och det andra värdet är containerporten.
Steg 2: Starta appen
Efter att ha angett instruktionerna i skrivfilen, starta programmet i en behållare med hjälp av ' docker-compose up ” kommando:
docker-compose up 
Steg 3: Verifiering
För verifiering, lista ner skrivbehållarna med hjälp av ' docker-compose ps ” kommando:
docker-komponera ps -a 
För att kontrollera om behållaren är tillgänglig på värddatorn, navigera till ' http://localhost:8080/ ' URL. Här kan du se att vi effektivt har vidarebefordrat containerporten på värden:
Hur man vidarebefordrar port till specifikt nätverk
För att vidarebefordra en containerport till ett specifikt nätverk måste användaren ange det nätverk på vilket de vill komma åt containern med hjälp av ' -nätverk ' alternativet. Titta på de givna stegen för demonstration.
Steg 1: Skapa ett nätverk
Skapa ett nytt nätverk med hjälp av ' docker-nätverk skapa
För att se Docker-nätverken, använd ' docker nätverk ls ” kommando:
hamnarnätverk lsHär har vi framgångsrikt skapat ' mygo-nätverk ' som använder ' bro ' förare:
Steg 2: Kartlägg nätverk
För att köra och komma åt behållaren på det specifika nätverket med portvidarebefordransteknik, använd kommandot nedan:
hamnarkörning -s 8080 : 8080 --nätverk mygo-nätverk golang-imgI det givna kommandot ' -s alternativet publicerar behållaren på en angiven port i det angivna nätverket. Här, ' -nätverk alternativet används för att definiera dockarnätverket:
För verifiering, navigera igen till ' http://localhost:8080 ” port och kontrollera om behållaren är tillgänglig på det angivna nätverket eller inte:
Ovanstående utdata indikerar att vi effektivt har vidarebefordrat containerporten på ett specifikt nätverk.
Notera: När du använder 'värd'-nätverket behöver användaren inte publicera porten från behållare till värd med hjälp av ' -s ' eller ' -publicera ' alternativet.
Vidarebefordra port till specifikt nätverk med Docker Compose
Lägg till följande utdrag i ' docker-compose.yml ' fil. I utdraget nedan, ' nätverk ”-tangenten används för att ange nätverket:
version: '3'tjänster:
webb:
bygga:.
hamnar:
- 8080 : 8080
Starta nu applikationen i en behållare med hjälp av ' docker-compose up ” kommando:
docker-compose up 
Vi har täckt metoderna för port forwarding i Docker.
Slutsats
För att vidarebefordra porten i Docker för åtkomst till dockerize-applikationen utanför behållaren kan användaren antingen använda ' -s ' eller ' -publicera ' alternativet i ' hamnarkörning ' kommandot eller så kan användaren använda ' hamnar ”-tangenten i Docker-skrivfilen. För att komma åt containern på ett specifikt nätverk kan användaren vidarebefordra containerporten på ett nätverk genom att använda ' –nätverk