Go என்பது ஒரு திறந்த மூல, நிலையான தட்டச்சு செய்யப்பட்ட மற்றும் தொகுக்கப்பட்ட நிரலாக்க மொழியாகும், இது ஒரு எளிய, நம்பகமான மற்றும் மிகவும் திறமையான மென்பொருளை உருவாக்குவதற்கான அதன் திறனுக்காக புகழ்பெற்றது. வலை பயன்பாடுகள், கிளவுட்-நேட்டிவ் தீர்வுகள், கட்டளை-வரி இடைமுகங்கள் (CLIகள்) உள்ளிட்ட பல்வேறு பயன்பாடுகளை வடிவமைப்பதில் இது பயன்பாட்டைக் கண்டறிகிறது, மேலும் டோக்கரே கூட Go ஐப் பயன்படுத்தி வடிவமைக்கப்பட்டுள்ளது.
எங்கள் விஷயத்தில், நாங்கள் எளிய HTTP சேவையகத்தை Go இல் உருவாக்குகிறோம், இது எளிய படிகளில் பயன்பாட்டை எவ்வாறு உருவாக்குவது மற்றும் ஆவணப்படுத்துவது என்பதை நிரூபிக்க அனுமதிக்கிறது.
தேவைகள்:
இந்த டுடோரியலைப் பின்பற்ற, உங்களுக்கு பின்வரும் கருவிகள் தேவை:
- நிறுவப்பட்ட Go கம்பைலர் (பதிப்பு 1.21 மற்றும் அதற்கு மேல் தேவை)
- உங்கள் ஹோஸ்ட் கணினியில் டோக்கர் எஞ்சினை இயக்குகிறது
- Go பயன்பாட்டைத் திருத்த ஒரு IDE அல்லது உரை திருத்தி. விஷுவல் ஸ்டுடியோ அல்லது விம்மைப் பயன்படுத்த பரிந்துரைக்கிறோம்
- Bash, ZSH, PowerShell போன்ற கட்டளை வரி மொழிபெயர்ப்பாளர்.
கொடுக்கப்பட்ட தேவைகள் பூர்த்தி செய்யப்பட்டவுடன், நாங்கள் தொடரலாம் மற்றும் பயன்பாட்டை எவ்வாறு உருவாக்குவது என்பதைக் கற்றுக்கொள்வோம்.
விண்ணப்பத்தை உருவாக்குதல்
அடுத்த படி எங்கள் பயன்பாட்டை உருவாக்க வேண்டும். எங்கள் விஷயத்தில், எளிய செய்தியுடன் பதிலளிக்கும் எளிய HTTP சேவையகத்தை நாங்கள் உருவாக்குகிறோம்.
Go திட்டத்தைச் சேமிக்க ஒரு கோப்பகத்தை உருவாக்குவதன் மூலம் தொடங்கவும். நீங்கள் எந்த பொருத்தமான பெயரையும் வழங்கலாம்.
$ mkdir go_serverகோப்பகத்திற்குச் சென்று, மூலக் குறியீட்டைச் சேமிக்க புதிய கோப்பை உருவாக்கவும். எங்கள் விஷயத்தில், 'main.go' கோப்பை அழைக்கிறோம், இது கோ மூலக் குறியீடு என்பதைக் குறிக்கிறது.
$ தொடுதல் முக்கிய.go
இறுதியாக, கோப்பைத் திருத்தி, பின்வருவனவற்றில் காட்டப்பட்டுள்ளபடி, பயன்பாட்டிற்கு மூலக் குறியீட்டைச் சேர்க்கவும்:
முக்கிய தொகுப்புஇறக்குமதி (
'fmt'
'net/http'
)
முக்கிய செயல்பாடு ( ) {
// உள்வரும் கோரிக்கைகளை கையாளவும்
http.HandleFunc ( '/' , செயல்பாடு ( இல் http.ResponseWriter, ஆர் * http.கோரிக்கை ) {
// வாடிக்கையாளருக்கு ஒரு பதிலை எழுதுங்கள்
fmt.Fprintf ( இல் , 'டோக்கரிடமிருந்து (:' )
} )
// போர்ட்டில் HTTP சேவையகத்தைத் தொடங்கவும் 8080
fmt.Println ( 'சர்வர் :8080 இல் இயங்குகிறது' )
http.ListenAndServe ( ':8080' , பூஜ்யம் )
}
முந்தைய பயன்பாடு ஒரு அடிப்படை HTTP சேவையகத்தை உருவாக்குகிறது, அது போர்ட் 8080 உடன் பிணைக்கிறது. சேவையகம் முன்பு வரையறுத்தபடி ஒரு அடிப்படை செய்தியுடன் பதிலளிக்கிறது.
விண்ணப்பத்தை சோதிக்கிறது
பயன்பாட்டை ஆவணப்படுத்துவதற்கு முன், பயன்பாடு சரியாகச் செயல்படுகிறதா என்பதை உறுதி செய்வோம். பின்வரும் கட்டளையை இயக்கவும்:
$ பிரதானமாக ஓடவும்.goமுந்தைய கட்டளை பயன்பாட்டைத் தொடங்கி, செய்தியை பின்வருமாறு வழங்குகிறது:
சர்வர் இயங்குகிறது: 8080அடுத்து, HTTP சேவையகத்தை சோதிக்க, நீங்கள் 'கர்ல்' கட்டளையை பின்வருமாறு இயக்கலாம்:
$ சுருட்டு http: // லோக்கல் ஹோஸ்ட்: 8080 /முந்தைய கட்டளை பின்வருமாறு செய்தியை அனுப்ப வேண்டும்:
டோக்கரிடமிருந்து ( : %அடுத்த படிகளில் வரையறுக்கப்பட்டுள்ளபடி முந்தைய பயன்பாட்டை இப்போது தொடரலாம் மற்றும் டாக்கரைஸ் செய்யலாம்.
விண்ணப்பத்தை கொள்கலன் செய்தல்
பயன்பாட்டிற்கான கொள்கலனை எவ்வாறு உருவாக்குவது என்பது பற்றி அடுத்த படிகள் விவாதிக்கப்படுகின்றன. திட்ட கோப்பகத்தில் Dockerfile ஐ உருவாக்குவதன் மூலம் தொடங்குகிறோம்.
$ சிடி go_serverஎந்த நீட்டிப்பும் இல்லாமல் Dockerfile என்ற கோப்பை உருவாக்கி, டெக்ஸ்ட் எடிட்டர் மூலம் கோப்பைத் திருத்தவும். எங்கள் பயன்பாட்டிற்கான அனைத்துத் தேவைகளையும் பின்வருமாறு வரையறுக்க இந்தக் கோப்பு அனுமதிக்கிறது:
$ தொடுதல் டோக்கர்ஃபைல்$ ஏனெனில் டோக்கர்ஃபைல்
கட்டமைப்பை பின்வருமாறு சேர்க்கவும்:
கோலாங்கிலிருந்து: 1.21பணிப்பாளர் / செயலி
நகலெடு. .
RUN go build main.go -ஓ முக்கிய .
வெளிப்படுத்து 8080
CMD [ './முக்கிய' ]
முந்தைய Dockerfile இல், பயன்பாட்டிற்கான முந்தைய செயல்பாடுகளை நாங்கள் வரையறுக்கிறோம்.
- அடிப்படை படத்தை அதிகாரப்பூர்வ கோலாங் பட பதிப்பு 1.21 க்கு அமைக்கவும்.
- கொள்கலனுக்குள் செயல்படும் கோப்பகத்தை “/app” ஆக உள்ளமைக்கவும்.
- முழு திட்ட கோப்பகத்தையும் கொள்கலனில் நகலெடுக்கிறோம்.
- கொள்கலனுக்குள் Go பயன்பாட்டை உருவாக்கவும்.
- உள்வரும் HTTP போக்குவரத்தை அனுமதிக்க போர்ட் 8080 ஐ வெளிப்படுத்தவும்.
- Go பயன்பாட்டை இயக்க கட்டளையை அமைக்கவும்.
டோக்கர் படத்தை உருவாக்குதல்
பயன்பாட்டிற்கான படத்தை உருவாக்க, முனையத்தைத் திறந்து, திட்டக் கோப்பகத்திற்குச் செல்லவும். அடுத்து, படத்தை உருவாக்க பின்வரும் கட்டளையை இயக்கவும்:
$ சூடோ டாக்கர் உருவாக்கம் -டி go_server_docker .பயன்பாட்டின் படத்தை நீங்கள் ஒதுக்க விரும்பும் பெயருடன் go_server_docker ஐ மாற்றவும்.
டோக்கர் படத்தை வெற்றிகரமாக உருவாக்கிய பிறகு, பின்வரும் கட்டளையுடன் அந்த படத்தின் அடிப்படையில் ஒரு கொள்கலனை இயக்கலாம்:
$ டாக்கர் ரன் -ப 8080 : 8080 go_server_dockerமுந்தைய கட்டளையானது போர்ட் 8080 ஐ ஹோஸ்ட் மெஷினிலிருந்து போர்ட் 8080 க்கு கொள்கலனுக்குள் வரைபடமாக்க வேண்டும்.
கொள்கலனை சோதிக்க, பின்வரும் கட்டளையை இயக்கவும்:
$ சுருட்டு http: // லோக்கல் ஹோஸ்ட்: 8080இது பயன்பாட்டில் வரையறுக்கப்பட்ட செய்தியை அச்சிட வேண்டும்.
முடிவுரை
இந்த டுடோரியலில், அடிப்படை Go பயன்பாட்டை எவ்வாறு உருவாக்குவது என்பதை நாங்கள் கற்றுக்கொண்டோம். Dockerfile இல் உள்ள தேவைகளை வரையறுத்தல், கண்டெய்னரில் இருந்து படத்தை உருவாக்குதல் மற்றும் படத்திலிருந்து கொள்கலனை இயக்குதல் ஆகியவற்றின் மூலம் பயன்பாட்டை எவ்வாறு கண்டெய்னரைஸ் செய்வது என்பதையும் நாங்கள் கற்றுக்கொண்டோம்.