गोलांग में HTTP / 1.1 और HTTP / 2 क्लाइंट और सर्वर लेखन

गोलंग एक बेहतरीन प्रोग्रामिंग भाषा है जिसमें कई तरह की सुविधाएँ हैं। यह आलेख दिखाता है कि आप गो और HTTP / 1.1 और HTTP / 2 प्रोटोकॉल के लिए क्लाइंट और सर्वर कैसे लिख सकते हैं।

स्किलबॉक्स सलाह देता है: स्क्रैच हैंड-ऑन कोर्स से पायथन डेवलपर ।

हम आपको याद दिलाते हैं: "हैबर" के सभी पाठकों के लिए - "हैबर" प्रोमो कोड का उपयोग करके किसी भी स्किलबॉक्स कोर्स के लिए पंजीकरण करते समय 10,000 रूबल की छूट।

HTTP / 2 वर्ल्ड वाइड वेब तक पहुँचने के लिए उपयोग किए जाने वाले HTTP नेटवर्क प्रोटोकॉल का दूसरा प्रमुख संस्करण है। प्रोटोकॉल SPDY पर आधारित है। GitHub पर इस संस्करण के बारे में अधिक जानें।

HTTP / 1.1 सर्वर

नीचे दिए गए कोड से पता चलता है कि गो पर HTTP / 1.1 सर्वर कैसे लिखना है। मुख्य फ़ंक्शन पोर्ट 9191 और पथ / हैलो / sayHello के साथ HTTP (एस) सेवा शुरू करता है। echoPayload इको लॉजिक के लिए जिम्मेदार है, जो आने वाले ट्रैफ़िक का विश्लेषण करता है और तदनुसार प्रतिक्रिया करता है। यदि आवश्यक हो, तो echoPayload को संशोधित किया जा सकता है।

package main import ( "fmt" "io/ioutil" "log" "net/http" ) func main() { http.HandleFunc("/hello/sayHello", echoPayload) log.Printf("Go Backend: { HTTPVersion = 1 }; serving on https://localhost:9191/hello/sayHello") log.Fatal(http.ListenAndServeTLS(":9191", "./cert/server.crt", "./cert/server.key", nil)) } func echoPayload(w http.ResponseWriter, req *http.Request) { log.Printf("Request connection: %s, path: %s", req.Proto, req.URL.Path[1:]) defer req.Body.Close() contents, err := ioutil.ReadAll(req.Body) if err != nil { log.Fatalf("Oops! Failed reading body of the request.\n %s", err) http.Error(w, err.Error(), 500) } fmt.Fprintf(w, "%s\n", string(contents)) 

चूंकि HTTP (S) सेवा पहले से चल रही है, इसलिए आपको एक प्रमाणपत्र और एक सर्वर कुंजी प्रदान करनी होगी। दोनों ऑब्जेक्ट्स सर्टिफिकेट डायरेक्टरी में server.crt और server.key के नाम से स्टोर किए जाते हैं।

एक प्रमाण पत्र और कुंजी का एक उदाहरण नीचे है।

./cert/server.crt

----- BEGIN CERTIFICATE -----
MIID + zCCAuOgAwIBAgIJAPsvGCCAC2i + MA0GCSqGSIb3DQEBCwUAMIGTMQswCQYD
VQQGEwJMSzEQMA4GA1UECAwHV2VzdGVybjEQMA4GA1UEBwwHQ29sb21ibzESMBAG
A1UECgwJTERDTEFLTUFMMRQwEgYDVQQLDAtFbmdpbmVlcmluZzESMBAGA1UEAwwJ
bG9jYWxob3N0MSIwIAYJKoZIhvcNAQkBFhNsZGNsYWttYWxAZ21haWwuY29tMB4X
DTE5MDQyMDA1MjczM1oXDTIwMDQxOTA1MjczM1owgZMxCzAJBgNVBAYTAkxLMRAw
DgYDVQQIDAdXZXN0ZXJuMRAwDgYDVQQHDAdDb2xvbWJvMRIwEAYDVQQKDAlMRENM
QUtNQUwxFDASBgNVBAsMC0VuZ2luZWVyaW5nMRIwEAYDVQQDDAlsb2NhbGhvc3Qx
IjAgBgkqhkiG9w0BCQEWE2xkY2xha21hbEBnbWFpbC5jb20wggEiMA0GCSqGSIb3
DQEBAQUAA4IBDwAwggEKAoIBAQC9PKAOlJcOBUI9CGnVjMjQHNRqYv01CaUdC4 / e
YFyegxLpoMpYvEC + nYlHT2j7BOhQBV + TkH1D4YOK2WP3V0FLv5hM7Nxsgf25WNHa
zi2DTBvcBgB9sDJA / avIvF + 63 + Btnyggp3xq6MaHy5DNH0kPnSiPiy7PRKToEUn6
oqPnB10rRBFZqs3ePmEDxVL3T / TUZSXR3P95fV1vDCqrJbr3YwWOzFCq8kEJFsxK
B7GSEKpPgmK0g5krmAQqUOuJJ3 / xFlCP4trKg / lvSJZ5S / LZD5teDDg6Ax3Mvthj
kMh9 / OM5GTTjRwhct9dHjFI8POj + TMbLZvoPVXjsmategtLAgMBAAGjUDBOMB0G
A1UdDgQWBBQ1CmWXmrHOv6b8f763 / bk80EpbajAfBgNVHSMEGDAWgBQ1CmWXmrHO
v6b8f763 / bk80EpbajAMBgNVHRMEBTADAQH / MA0GCSqGSIb3DQEBCwUAA4IBAQAH
D51Uoe2K4N9 / GxRgww5mMW2dUJ7Hc / tGsr / J1fNqHY8SXNAn5i + GwI + xBvwxHHL3
KZHbfq7eYDE5EItt3cZp5ySSscdTEay9ReH2 + 8k32gpH46CMwPV3XvtQuBVVAC4u
szrq1eWKhYI2zf4iUVpwvq89OynVGIp0atng + q3A2cBhi3NGo6Ho1s2rywQyqiq8
up4PUSVQ6WBoJFx5PEEDxD84VMS7Pan6dT34b9n56tq5R06retZTUZ8jMM88CGX4
88pSPU + XImp6DdNVBmW6Lz76jiSNHLkZGm4jumjeyUGzBjBEBOgSegeWlinMtWE9
gaVxeUHrqHk8xzwJ4oIu
----- END प्रमाण पत्र -----

./cert/server.key

----- BEGIN निजी कुंजी -----
MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC9PKAOlJcOBUI9
CGnVjMjQHNRqYv01CaUdC4 / eYFyegxLpoMpYvEC + nYlHT2j7BOhQBV + TkH1D4YOK
2WP3V0FLv5hM7Nxsgf25WNHazi2DTBvcBgB9sDJA / avIvF + 63 + Btnyggp3xq6MaH
y5DNH0kPnSiPiy7PRKToEUn6oqPnB10rRBFZqs3ePmEDxVL3T / TUZSXR3P95fV1v
DCqrJbr3YwWOzFCq8kEJFslKB7GSEKpPgmK0g5krmAQqUOCJ3 / xFlCP4trKg / lv
SJZ5S / LZD5teDDg6Ax3MvthjkMh9 / OM5GGTTjRwhct9dHjFI8POj + TMbLZvoPVXj
smATEgtLAgMBAAECggEAbaS2yDvn2cPKQTqit4y + vXY2zP1V4GkaNd4BGcOTZnRj
fOIg25EXoln8tEiadva888BpREKvkakUYlraxPDVcGIuiEOk42nd7Io97R0Q2cY7
ThxcJHb2ZxmTctdSUCBvFJTm1ySzve3pOb0ExRSfbGCOo7zs / kKzmZKK3qFlffGS
Ga9O7hylouXPU22CM + 5Lq0JPTER73z0DpAweZc0L14j6dzhcG3qUwk0K6K47VZgE
NhEORul7xDj91bh2iEoSbaQe8HxLaMQoMXOC / 9o22UKKTe9WZE3 + XCvg + vkw / sS
biQ + b4EZ9LuhAhCZ0UE6 + y7PZY + 8G / YsbGg0Zo8cAQKBgQDyTuG47rWBgbdHBE /
MSKGU6w + a1SdLk6jG + Enji5Q624 / h0xt5nF9ah2eRf3Rlhn9WEKM / uE9ouEODBKE
8rIDsjufEMI8moPEloRBSsxPNw + fNMSSCZjL + qPtTJUbRio7WA23sfdnE57ygBa
wlPQ9UBBWSm2se4veEZtHjtngQKBgQDH7gnH5Att6ZYazRTgD72g0C5v1l4LYVEQ
jxdBcs6TJA8wHfifZ45F67W95QunmM813UxfS + ybdjytlb8 / lmi2BnK6lDx5HWIL
31jnbg2CxCrNv9oZLjKVDmkp4WUcEp5W33R1 / MGDTRfyARP + 6QYQO / ATMdqtm5Uu
cD6clrL4ywKBgQCQ0niy0WmGaAMlQ8CoxLM / 2c6 + 1 + OQtlalwkoGHEKudqhELBeQ
MAVw0fW13Vtg4vfRpejQ4J26 + xjMDocbEv / bBIsvjvF57XlaXLucJJy2Jwv0BSMa
cCkRa1gkYeyek74DaSzyXqDSYVO / RPKFTFRQNeUbqbD20s3rbVWablFPAQKBgB5y
zUCJJYh2w6qPQzegjhO4wOm9bxMyngL0l + ka0AUuv7VnSx8TyWIytLoX8P90UVJ1
wpTc3ksK5dDV9ot7n7ThJIXv34nehLkkKckNRLd + oro1FsUw + PkkebWsIxb0avL2
EymI9fvGOPhdW6s91 / OO / VAfDpvUDxNEevSkKtujAoGAcMOsXtn / UyT3Lssxgla3
K + DCaFhAQPSUXOmpZwEbQ0yQlksDe4flsam8bEDI5D5iHx1ziSfh583qJl3BEZ5u
VZTEO2YLvT9QRz7pv2qspqj7nzSyBU2BFAajq43 / G1b8FHfVgN + YdVtzVrigfql5
2a + JxOxFfpjnGQ7RfSxSb + Q =
----- END निजी कुंजी -----

यह निम्नलिखित कमांड का उपयोग करके सेवा चलाने का परीक्षण करने का समय है:

 $ go run http_server.go 

उत्तर इस तरह होना चाहिए:

 Go Backend: { HTTPVersion = 1 }; serving on https://localhost:9191/hello/sayHello 

अब हम HTTP / 1.1 POST अनुरोध (असुरक्षित और सुरक्षित मोड) का उपयोग करके सेवा आरंभ करते हैं:

 $ curl -k -v https://localhost:9191/hello/sayHello -d "Hello Go!" $ curl -v --cacert ./cert/server.crt https://localhost:9191/hello/sayHello -d "Hello Go!" 

नीचे कार्यक्रम का परिणाम है। पहला भाग टीएलएस सर्वर और क्लाइंट का हैंडशेक विवरण है। दूसरा HTTP / 1.1 अनुरोध और प्रतिक्रिया का विवरण है। अंत में टेक्स्ट मैसेज "हेलो गो!" है।

* 127.0.0.1 की कोशिश कर रहा है ...
* लोकलहोस्ट से जुड़ा (127.0.0.1) पोर्ट 9191 (# 0)
* ALPN, http / 1.1 की पेशकश
* सिफर चयन: ALL:! EXPORT:! EXPORT40:! EXPORT56:! ANULL:! LOW:! RC4: @STRENGTH
* सफलतापूर्वक प्रमाण पत्र सत्यापित स्थानों को सेट करें:
* CAfile: /etc/ssl/certs/ca-certports.crt
CApath: कोई नहीं
* TLSv1.2 (OUT), TLS हेडर, सर्टिफिकेट स्टेटस (22):
* TLSv1.2 (OUT), TLS हैंडशेक, क्लाइंट हैलो (1):
* TLSv1.2 (IN), TLS हैंडशेक, सर्वर हैलो (2):
* TLSv1.2 (IN), TLS हैंडशेक, प्रमाणपत्र (11):
* TLSv1.2 (IN), TLS हैंडशेक, सर्वर कुंजी विनिमय (12):
* TLSv1.2 (IN), TLS हैंडशेक, सर्वर समाप्त (14):
* TLSv1.2 (OUT), TLS हाथ मिलाना, ग्राहक कुंजी विनिमय (16):
* TLSv1.2 (OUT), TLS परिवर्तन सिफर, क्लाइंट हैलो (1):
* TLSv1.2 (OUT), TLS हैंडशेक, समाप्त (20):
* TLSv1.2 (IN), TLS परिवर्तन सिफर, क्लाइंट हैलो (1):
* TLSv1.2 (IN), TLS हैंडशेक, समाप्त (20):
* SSL कनेक्शन TLSv1.2 / ECDHE-RSA-AES128-GCM-SHA256 का उपयोग कर
* ALPN, सर्वर ने http / 1.1 का उपयोग करना स्वीकार किया
* सर्वर प्रमाणपत्र:
* विषय: सी = एलके; एसटी = पश्चिमी; एल = कोलंबो; O = LDCLAKMAL; ओयू = इंजीनियरिंग; सीएन = चनाका लकमल; emailAddress=ldclakmal@gmail.com
* प्रारंभ तिथि: अप्रैल 20 03:03:58 2019 जीएमटी
* समय सीमा समाप्त: अप्रैल 19 03:03:58 2020 GMT
* जारीकर्ता: सी = एलके; एसटी = पश्चिमी; एल = कोलंबो; O = LDCLAKMAL; ओयू = इंजीनियरिंग; सीएन = चनाका लकमल; emailAddress=ldclakmal@gmail.com
* एसएसएल प्रमाणपत्र सत्यापन परिणाम: स्व हस्ताक्षरित प्रमाण पत्र (18), वैसे भी जारी है।
> POST / हैलो / SayHello HTTP / 1.1
> मेजबान: लोकलहोस्ट: 9191
> उपयोगकर्ता-एजेंट: कर्ल / 7.46.0
> स्वीकार करें: * / *
> सामग्री-लंबाई: 9
> सामग्री-प्रकार: आवेदन / x-www-form-urlencoded
>
* अपलोड पूरी तरह से बंद भेज दिया: 9 बाइट्स में से 9
<HTTP / 1.1 200 ठीक है
<दिनांक: शनि, 20 अप्रैल 2019 06:56:19 जीएमटी
<सामग्री-लंबाई: 10
<सामग्री-प्रकार: पाठ / सादा; charset = utf-8
<
नमस्कार जाओ!
* कनेक्शन # 0 स्थानीय होस्ट छोड़ दिया होस्ट करने के लिए

HTTP / 1.1 क्लाइंट

नया कोड गो पर एक साधारण HTTP / 1.1 क्लाइंट लिखने का एक उदाहरण है। यह ग्राहक "हैलो हैलो!" संदेश के साथ एक एचटीटीपी (एस) पोस्ट रिक्वेस्ट को लोकलहोस्ट : 9191 / हैलो / कहेहेलो भेजता है।

 package main import ( "bytes" "crypto/tls" "crypto/x509" "fmt" "io/ioutil" "log" "net/http" ) func main() { client := &http.Client{} // Create a pool with the server certificate since it is not signed // by a known CA caCert, err := ioutil.ReadFile("./cert/server.crt") if err != nil { log.Fatalf("Reading server certificate: %s", err) } caCertPool := x509.NewCertPool() caCertPool.AppendCertsFromPEM(caCert) // Create TLS configuration with the certificate of the server tlsConfig := &tls.Config{ RootCAs: caCertPool, } // Use the proper transport in the client client.Transport = &http.Transport{ TLSClientConfig: tlsConfig, } // Perform the request resp, err := client.Post("https://localhost:9191/hello/sayHello", "text/plain", bytes.NewBufferString("Hello Go!")) if err != nil { log.Fatalf("Failed get: %s", err) } defer resp.Body.Close() body, err := ioutil.ReadAll(resp.Body) if err != nil { log.Fatalf("Failed reading response body: %s", err) } fmt.Printf("Got response %d: %s %s", resp.StatusCode, resp.Proto, string(body)) 

चूंकि HTTP (एस) सेवा भी यहां से शुरू होती है, इसलिए आपको एक प्रमाण पत्र और एक कुंजी प्रदान करनी होगी। आवश्यक डेटा को सर्टिफिकेट डायरेक्टरी में server.crt और server.key नाम के साथ रखा गया है।

क्लाइंट को शुरू करने के लिए, आपको सर्वर को इनिशियलाइज़ करना होगा। ऐसा करने के लिए, हम पहले खंड में वर्णित क्रिया करते हैं, या हम पोर्ट 9191 और पथ / हैलो / SayHello के साथ किसी भी HTTP (एस) सेवा शुरू करते हैं।

 $ go run http_client.go 

आउटपुट इस तरह होना चाहिए:

 Got response 200: HTTP/1.1 Hello Go! 

क्लाइंट कर्ल कमांड के संचालन को दिखाता है:

 $ curl -v --cacert ./cert/server.crt https://localhost:9191/hello/sayHello -d "Hello Go!" 

HTTP / 1.1 के साथ काम खत्म करने के बाद, आपको HTTP / 2 के लिए वही दोहराने की कोशिश करनी चाहिए।

HTTP / 2 सर्वर

पिछले भाग की तरह, आपको पहले एक इको सर्वर बनाना होगा।

 package main import ( "fmt" "golang.org/x/net/http2" "io/ioutil" "log" "net/http" ) func main() { var httpServer = http.Server{ Addr: ":9191", } var http2Server = http2.Server{} _ = http2.ConfigureServer(&httpServer, &http2Server) http.HandleFunc("/hello/sayHello", echoPayload) log.Printf("Go Backend: { HTTPVersion = 2 }; serving on https://localhost:9191/hello/sayHello") log.Fatal(httpServer.ListenAndServeTLS("./cert/server.crt", "./cert/server.key")) } func echoPayload(w http.ResponseWriter, req *http.Request) { log.Printf("Request connection: %s, path: %s", req.Proto, req.URL.Path[1:]) defer req.Body.Close() contents, err := ioutil.ReadAll(req.Body) if err != nil { log.Fatalf("Oops! Failed reading body of the request.\n %s", err) http.Error(w, err.Error(), 500) } fmt.Fprintf(w, "%s\n", string(contents)) 

सर्वर की जांच करने के लिए, आपको कमांड भेजने की आवश्यकता है:

 $ go run http2_server.go 

उत्तर इस तरह होना चाहिए:

 Go Backend: { HTTPVersion = 2 }; serving on https://localhost:9191/hello/sayHello 

अब सर्वर चल रहा है, आप इसे HTTP / 1.1 या HTTP / 2 अनुरोधों का उपयोग करके आरंभ कर सकते हैं। सर्वर ऑपरेशन के परीक्षण के लिए HTTP / 1.1 POST कमांड नीचे दिए गए हैं:

 $ curl -k -v https://localhost:9191/hello/sayHello -d "Hello Go!" $ curl -v --cacert ./cert/server.crt https://localhost:9191/hello/sayHello -d "Hello Go!" 

और यही बात, लेकिन HTTP / 2 POST के साथ:

 $ curl -k -v --http2 https://localhost:9191/hello/sayHello -d "Hello Go!" $ curl -v --http2 --cacert ./cert/server.crt https://localhost:9191/hello/sayHello -d "Hello Go!" 

नीचे सर्वर ऑपरेशन आउटपुट का एक उदाहरण है। पहला भाग सर्वर और क्लाइंट के बीच एक TLS हैंडशेक है, दूसरा HTTP / 2 अनुरोध और प्रतिक्रिया का विवरण है।

* 127.0.0.1 की कोशिश कर रहा है ...
* लोकलहोस्ट से जुड़ा (127.0.0.1) पोर्ट 9191 (# 0)
* ALPN, h2 की पेशकश
* ALPN, http / 1.1 की पेशकश
* सिफर चयन: ALL:! EXPORT:! EXPORT40:! EXPORT56:! ANULL:! LOW:! RC4: @STRENGTH
* सफलतापूर्वक प्रमाण पत्र सत्यापित स्थानों को सेट करें:
* CAfile: src / hello / cert / server.crt
CApath: कोई नहीं
* TLSv1.2 (OUT), TLS हेडर, सर्टिफिकेट स्टेटस (22):
* TLSv1.2 (OUT), TLS हैंडशेक, क्लाइंट हैलो (1):
* TLSv1.2 (IN), TLS हैंडशेक, सर्वर हैलो (2):
* TLSv1.2 (IN), TLS हैंडशेक, प्रमाणपत्र (11):
* TLSv1.2 (IN), TLS हैंडशेक, सर्वर कुंजी विनिमय (12):
* TLSv1.2 (IN), TLS हैंडशेक, सर्वर समाप्त (14):
* TLSv1.2 (OUT), TLS हाथ मिलाना, ग्राहक कुंजी विनिमय (16):
* TLSv1.2 (OUT), TLS परिवर्तन सिफर, क्लाइंट हैलो (1):
* TLSv1.2 (OUT), TLS हैंडशेक, समाप्त (20):
* TLSv1.2 (IN), TLS परिवर्तन सिफर, क्लाइंट हैलो (1):
* TLSv1.2 (IN), TLS हैंडशेक, समाप्त (20):
* SSL कनेक्शन TLSv1.2 / ECDHE-RSA-AES128-GCM-SHA256 का उपयोग कर
* ALPN, सर्वर ने h2 का उपयोग करना स्वीकार किया
* सर्वर प्रमाणपत्र:
* विषय: सी = एलके; एसटी = पश्चिमी; एल = कोलंबो; O = LDCLAKMAL; ओयू = इंजीनियरिंग; CN = लोकलहोस्ट; emailAddress=ldclakmal@gmail.com
* प्रारंभ दिनांक: अप्रैल 20 05:27:33 2019 GMT
* समय सीमा समाप्त: अप्रैल 19 05:27:33 2020 GMT
* सामान्य नाम: लोकलहोस्ट (मिलान)
* जारीकर्ता: सी = एलके; एसटी = पश्चिमी; एल = कोलंबो; O = LDCLAKMAL; ओयू = इंजीनियरिंग; CN = लोकलहोस्ट; emailAddress=ldclakmal@gmail.com
* एसएसएल प्रमाण पत्र ठीक सत्यापित करें।
* HTTP2 का उपयोग करते हुए, सर्वर बहु-उपयोग का समर्थन करता है
* कनेक्शन स्थिति परिवर्तित (HTTP / 2 पुष्टिकरण)
* TCP_NODELAY सेट
* उन्नयन के बाद बफर को जोड़ने के लिए स्ट्रीम बफर में HTTP / 2 डेटा कॉपी करना: len = 0
* स्ट्रीम आईडी का उपयोग करना: 1 (आसान हैंडल 0x10ddf20)
> POST / हैलो / SayHello HTTP / 1.1
> मेजबान: लोकलहोस्ट: 9191
> उपयोगकर्ता-एजेंट: कर्ल / 7.46.0
> स्वीकार करें: * / *
> सामग्री-लंबाई: 9
> सामग्री-प्रकार: आवेदन / x-www-form-urlencoded
>
* हम पूरी तरह से अपलोड और ठीक हैं
<HTTP / 2.0 200
<सामग्री-प्रकार: पाठ / सादा; charset = utf-8
<सामग्री-लंबाई: 10
<दिनांक: शनि, 20 अप्रैल 2019 06:54:50 जीएमटी
<
नमस्कार जाओ!
* कनेक्शन # 0 स्थानीय होस्ट छोड़ दिया होस्ट करने के लिए

HTTP / 2 ग्राहक

अंतिम भाग HTTP / 2 क्लाइंट बना रहा है। यहां स्थानीयहोस्ट के लिए HTTP (S) POST अनुरोध भेजने का कार्यान्वयन है: 9191 / हैलो / sayHello:

 package main import ( "bytes" "crypto/tls" "crypto/x509" "fmt" "golang.org/x/net/http2" "io/ioutil" "log" "net/http" ) func main() { client := &http.Client{} // Create a pool with the server certificate since it is not signed // by a known CA caCert, err := ioutil.ReadFile("./cert/server.crt") if err != nil { log.Fatalf("Reading server certificate: %s", err) } caCertPool := x509.NewCertPool() caCertPool.AppendCertsFromPEM(caCert) // Create TLS configuration with the certificate of the server tlsConfig := &tls.Config{ RootCAs: caCertPool, } // Use the proper transport in the client client.Transport = &http2.Transport{ TLSClientConfig: tlsConfig, } // Perform the request resp, err := client.Post("https://localhost:9191/hello/sayHello", "text/plain", bytes.NewBufferString("Hello Go!")) if err != nil { log.Fatalf("Failed get: %s", err) } defer resp.Body.Close() body, err := ioutil.ReadAll(resp.Body) if err != nil { log.Fatalf("Failed reading response body: %s", err) } fmt.Printf("Got response %d: %s %s", resp.StatusCode, resp.Proto, string(body)) 

पहले की तरह, आपको काम करने के लिए एक कुंजी और एक प्रमाण पत्र की आवश्यकता है। वे सर्टिफिकेट के साथ सर्वर में संग्रहित होते हैं। सर्वर और सर्वर।की।

क्लाइंट लॉन्च:

 $ go run http2_client.go 

और अपेक्षित जवाब:

 Got response 200: HTTP/2 Hello Go! 

ग्राहक का पता लगाना:

 $ curl -v --http2 --cacert ./cert/server.crt https://localhost:9191/hello/sayHello -d "Hello Go!" 

वह सब है। काम अपेक्षाकृत सरल है, लेकिन यह गो में बुनियादी नेटवर्क सेवाओं को कैसे लागू किया जाए, इसकी समझ देता है।

स्किलबॉक्स अनुशंसा करता है:

• दो वर्षीय व्यावहारिक पाठ्यक्रम "मैं एक प्रो वेब डेवलपर हूं । "
• शैक्षिक ऑनलाइन पाठ्यक्रम "पेशे जावा-डेवलपर" ।
• व्यावहारिक वार्षिक पाठ्यक्रम "पीएचपी-डेवलपर 0 से प्रो तक" ।