Go er et åpen kildekode, statisk skrevet og kompilert programmeringsspråk som er kjent for sin evne til å lette utviklingen av en enkel, pålitelig og svært effektiv programvare. Den finner nytten ved å lage forskjellige applikasjoner, inkludert nettapper, skybaserte løsninger, kommandolinjegrensesnitt (CLI), og spennende nok er selve Docker laget med Go.
I vårt tilfelle bygger vi en enkel HTTP-server i Go som lar oss demonstrere hvordan man bygger og dokker applikasjonen i enkle trinn.
Krav:
For å følge med på denne opplæringen trenger du følgende verktøy:
- Installert Go-kompilator (versjon 1.21 og nyere kreves)
- Kjører Docker Engine på vertsmaskinen din
- En IDE- eller tekstredigerer for å redigere Go-applikasjonen. Vi anbefaler å bruke Visual Studio eller Vim
- En kommandolinjetolk som Bash, ZSH, PowerShell, etc.
Med de gitte kravene oppfylt, la oss fortsette og lære hvordan du bygger applikasjonen.
Bygge applikasjonen
Det neste trinnet er å bygge vår applikasjon. I vårt tilfelle bygger vi en enkel HTTP-server som svarer med en enkel melding.
Start med å lage en katalog for å lagre Go-prosjektet. Du kan oppgi hvilket som helst passende navn.
$ mkdir go_serverNaviger inn i katalogen og lag en ny fil for å lagre kildekoden. I vårt tilfelle kaller vi 'main.go'-filen som angir at filen er en Go-kildekode.
$ ta på main.go
Til slutt, rediger filen og legg til kildekoden til applikasjonen som vist i følgende:
hovedpakkeimport (
'fmt'
'net/http'
)
func main ( ) {
// håndtere innkommende forespørsler
http.HandleFunc ( '/' , funk ( I http.ResponseWriter, r * http.Request ) {
// Skriv et svar til klienten
fmt.Fprintf ( I , 'Fra Docker (:' )
} )
// Start HTTP-serveren på porten 8080
fmt.Println ( 'Tjeneren kjører på :8080' )
http.ListenAndServe ( ':8080' , null )
}
Den forrige applikasjonen oppretter en grunnleggende HTTP-server som binder seg til port 8080. Serveren svarer med en grunnleggende melding som tidligere definert.
Tester applikasjonen
Før vi dokker applikasjonen, la oss sørge for at appen fungerer som den skal. Kjør følgende kommando:
$ gå løp main.goDen forrige kommandoen starter programmet og returnerer meldingen som følger:
Server kjører på: 8080Deretter, for å teste HTTP-serveren, kan du kjøre 'curl'-kommandoen som følger:
$ krølle http: // lokal vert: 8080 /Den forrige kommandoen skal returnere meldingen som følger:
Fra Docker ( : %Vi kan nå fortsette og dokke den forrige applikasjonen som definert i de neste trinnene.
Containerisering av applikasjonen
De neste trinnene er å diskutere hvordan man bygger en beholder for applikasjonen. Vi starter med å lage Dockerfilen i prosjektkatalogen.
$ cd go_serverLag en fil kalt Dockerfile uten utvidelse og rediger filen med et tekstredigeringsprogram. Denne filen lar oss definere alle kravene til søknaden vår som følger:
$ ta på Dockerfil$ fordi Dockerfil
Legg til konfigurasjonen som følger:
FRA golang: 1.21WORKDIR / app
KOPI . .
KJØR gå bygge main.go -O hoved.
AVDEKKE 8080
CMD [ './hoved' ]
I forrige Dockerfile definerer vi de tidligere operasjonene for applikasjonen.
- Sett grunnbildet til den offisielle Golang-bildet versjon 1.21.
- Konfigurer arbeidskatalogen inne i beholderen til '/app'.
- Vi kopierer hele prosjektkatalogen inn i beholderen.
- Bygg Go-applikasjonen inne i beholderen.
- Utsett port 8080 for å tillate innkommende HTTP-trafikk.
- Still inn kommandoen for å kjøre Go-applikasjonen.
Bygge Docker-bildet
For å bygge bildet for applikasjonen, åpne terminalen og naviger til prosjektkatalogen. Kjør deretter følgende kommando for å bygge bildet:
$ sudo dockerbygg -t go_server_docker .Erstatt go_server_docker med navnet du vil tilordne appbildet.
Etter å ha bygget Docker-bildet, kan du kjøre en beholder basert på det bildet med følgende kommando:
$ docker run -s 8080 : 8080 go_server_dockerDen forrige kommandoen skal kartlegge port 8080 fra vertsmaskinen til port 8080 inne i beholderen.
For å teste beholderen, kjør følgende kommando:
$ krølle http: // lokal vert: 8080Dette skal skrive ut meldingen som er definert i applikasjonen.
Konklusjon
I denne opplæringen lærte vi hvordan du lager en grunnleggende Go-applikasjon. Vi lærte også hvordan vi kan beholde applikasjonen ved å definere kravene i Dockerfilen, bygge bildet fra beholderen og kjøre beholderen fra bildet.