Go är ett öppen källkod, statiskt skrivet och kompilerat programmeringsspråk som är känt för sin förmåga att underlätta utvecklingen av en enkel, pålitlig och mycket effektiv programvara. Den finner nyttan i att skapa olika applikationer inklusive webbappar, molnbaserade lösningar, kommandoradsgränssnitt (CLI) och spännande nog är till och med Docker själv skapad med Go.
I vårt fall bygger vi en enkel HTTP-server i Go som låter oss demonstrera hur man bygger och dockeriserar applikationen i enkla steg.
Krav:
För att följa med i denna handledning behöver du följande verktyg:
- Installerad Go-kompilator (version 1.21 och högre krävs)
- Kör Docker Engine på din värddator
- En IDE- eller textredigerare för att redigera Go-applikationen. Vi rekommenderar att du använder Visual Studio eller Vim
- En kommandoradstolk som Bash, ZSH, PowerShell, etc.
Med de givna kraven uppfyllda, låt oss fortsätta och lära oss hur man bygger applikationen.
Bygger applikationen
Nästa steg är att bygga vår applikation. I vårt fall bygger vi en enkel HTTP-server som svarar med ett enkelt meddelande.
Börja med att skapa en katalog för att lagra Go-projektet. Du kan ange vilket passande namn som helst.
$ mkdir go_serverNavigera in i katalogen och skapa en ny fil för att lagra källkoden. I vårt fall kallar vi filen 'main.go', vilket anger att filen är en Go-källkod.
$ Rör main.go
Slutligen, redigera filen och lägg till källkoden till applikationen som visas i följande:
huvudpaketetimportera (
'fmt'
'net/http'
)
func huvud ( ) {
// hantera inkommande förfrågningar
http.HandleFunc ( '/' , func ( I http.ResponseWriter, r * http.Begäran ) {
// Skriv ett svar till kunden
fmt.Fprintf ( I , 'Från Docker (:' )
} )
// Starta HTTP-servern på porten 8080
fmt.Println ( 'Server körs på :8080' )
http.ListenAndServe ( ':8080' , noll )
}
Den tidigare applikationen skapar en grundläggande HTTP-server som binder till port 8080. Servern svarar med ett grundläggande meddelande som tidigare definierats.
Testa applikationen
Innan vi dockar applikationen, låt oss se till att appen fungerar korrekt. Kör följande kommando:
$ gå spring main.goDet föregående kommandot startar programmet och returnerar meddelandet enligt följande:
Servern körs på: 8080Därefter, för att testa HTTP-servern, kan du köra kommandot 'curl' enligt följande:
$ curl http: // lokal värd: 8080 /Det föregående kommandot ska returnera meddelandet enligt följande:
Från Docker ( : %Vi kan nu fortsätta och dockerisera den tidigare applikationen enligt definitionen i nästa steg.
Containerizing applikationen
Nästa steg är att diskutera hur man bygger en container för applikationen. Vi börjar med att skapa Dockerfilen i projektkatalogen.
$ CD go_serverSkapa en fil som heter Dockerfile utan tillägg och redigera filen med en textredigerare. Denna fil låter oss definiera alla krav för vår ansökan enligt följande:
$ Rör Dockerfil$ därför att Dockerfil
Lägg till konfigurationen enligt följande:
FRÅN golang: 1.21WORKDIR / app
KOPIERA . .
KÖR gå bygg main.go -O huvud.
ÖVERSIKT 8080
CMD [ './main' ]
I den tidigare Dockerfilen definierar vi de tidigare operationerna för applikationen.
- Ställ in basbilden till den officiella Golang-bilden version 1.21.
- Konfigurera arbetskatalogen inuti behållaren till '/app'.
- Vi kopierar hela projektkatalogen till behållaren.
- Bygg Go-applikationen inuti behållaren.
- Exponera port 8080 för att tillåta en inkommande HTTP-trafik.
- Ställ in kommandot för att köra Go-applikationen.
Bygga Docker-bilden
För att bygga bilden för applikationen, öppna terminalen och navigera till projektkatalogen. Kör sedan följande kommando för att bygga bilden:
$ sudo hamnarbyggare -t go_server_docker .Ersätt go_server_dockern med namnet som du vill tilldela appbilden.
Efter att ha lyckats bygga Docker-bilden kan du köra en behållare baserad på den bilden med följande kommando:
$ hamnarkörning -s 8080 : 8080 go_server_dockerDet föregående kommandot bör mappa port 8080 från värddatorn till port 8080 inuti behållaren.
För att testa behållaren, kör följande kommando:
$ curl http: // lokal värd: 8080Detta bör skriva ut meddelandet som är definierat i programmet.
Slutsats
I den här handledningen lärde vi oss hur man skapar en grundläggande Go-applikation. Vi lärde oss också hur man containeriserar applikationen genom att definiera kraven i Dockerfilen, bygga bilden från behållaren och köra behållaren från bilden.