🥇Evolutionis interretialis servientibus in Golang - ex simplici ad complexum

Quinque annos coepi develop Gophishhaec occasio discendi Golang. Intellexi Ire linguam potentem esse, multis bibliothecis completam. Ite versatile est: in particulari, adhiberi potest ut applicationes servo laterali sine ullis quaestionibus excolantur.

Hic articulus est de servo scribens in Go. Incipiamus a rebus simplicibus sicut "Salve mundum" et finem cum applicatione cum facultatibus sequentibus;

- Usura Lets Encrypt pro HTTPS.
— Opus ut API iter.
— Working with middleware.
— Processing of static files.
- Recte shutdown.

Skillbox commendat: Cursus practicus "Phython elit a VULNUS".

admonemus; omnibus legentibus "Habr" - discount 10 rublorum cum scribendo in quavis Skillbox utens "Habr" codice promotivo.

Salve, orbis terrarum!

Tu telam ministram creare potes in Ite celerrime. Ecce exemplum tracto utendi qui reddit “Salve, mundum!” supra promissum.

package main
 
import (
"fmt"
"net/http"
)
 
func main() {
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello World!")
})
http.ListenAndServe(":80", nil)
}

Post haec, si applicationes curris et paginam aperi localhostergo statim textum “Salve, mundum” videbis! (si omnia recte, utique).

Pluribus vicibus tracto utemur, sed primum quomodo omnia opera intelligamus.

retia / http "

Exemplum usus est sarcina net/http, est instrumentum primarium in Go ad excolendas tam servientes quam clientes HTTP. Ut signum cognoscamus, intellegamus significationem trium magnitudinum elementorum: http.Handler, http.ServeMux et http.Server.

HTTP tracto

Cum petitionem accipimus, tracto eam enucleat et responsionem generat. Tractatores in Go adducuntur hoc modo:

type Handler interface {
        ServeHTTP(ResponseWriter, *Request)
}

Primum exemplum in http.HandleFunc munus adiutorium adhibet. Aliud munus involvit quod vicissim http.ResponseWriter et http.Request in ServeHTTP sumit.

Aliis verbis tracto in Golang sistuntur in uno interface, quod multam optiones programmatori dat. Sic, exempli gratia, media cautela adhibeatur utens tracto, ubi ServeHTTP primum aliquid agit et deinde modum tractatoris alterius ServeHTTP vocat.

Ut supra, tracto responsiones petitiones simpliciter generant. Sed quae maxime tracto utendum est in aliquo puncto tempore?

Request Routing

Ad rectam electionem utere, multiplicatore HTTP utere. In pluribus bibliothecis dicitur muxer vel iter, sed idem sunt omnes. Munus multiplexer est iter petitionis resolvere et tracto aptam eligere.

Si subsidia ad fusuram complexam indiges, melius est ut bibliothecae tertiae factionis utantur. Quidam antecedens - muta/mux и ire-chi / chihae bibliothecae efficere possunt ut processus intermedius sine ullis problematibus efficiatur. Eorum ope, configurare potes wildcardum fundere et plura alia munera exercere. Utilitas earum est convenientiae cum tracto vexillum HTTP. Quam ob rem, codicem simplicem scribere potes qui in futurum mutari potest.

Laborans cum complexis compagibus in situ normali solutiones non normas requiret, et hoc signanter involvit usum tracto defaltae. Ad maximam partem applicationum creandum, coniunctio bibliothecae defaltae et iter simplex satis erit.

Query Processing

Praeterea necessaria est pars quae "audire" vult ad nexus ineuntes et omnes petitiones correcto tracto redigere. http.Server hoc negotium facile tractamus.

Ex sequentibus patet servo responsalem esse omnium operarum quae ad processum nexum referuntur. Hoc, exempli gratia, opera TLS protocollo utens. Ad efficiendum http.ListenAndServer vocatus, signum HTTP servo adhibetur.

Nunc exempla plura videamus.

Addens Lets Encrypt

Defalta nostra applicatio protocollo HTTP percurrit, sed commendatur protocollo HTTPS uti. Hoc sine problematibus in Go. Si libellum ac clavem privatam acceperis, satis tum est audiAndServeTLS subcriptio cum certificatorio et clavibus actis.

http.ListenAndServeTLS(":443", "cert.pem", "key.pem", nil)

Semper potes melius facere.

Sit scriptor Encrypt liberum testimonium praebet renovatio latae sententiae. Ut servitio utere, sarcina opus est autocert.

Modus configurandi facillime est autocerto utendi. Methodus NewListener in compositione cum http.Serve. Methodus tibi permittit ut libellos TLS obtineas et renovas dum HTTP processuum petitiones servo:

http.Serve(autocert.NewListener("example.com"), nil)

Si in pasco aperimus example.com, responsum HTTPS accipiemus "Salve, mundum!"

Si accuratiorem configurationem debes, autocert.Manager procurator utere debes. Tum nostram http.Instantiam nostram creamus (usque ad hoc defaltam usi sumus) et procuratori ad TLSConfig servo addimus:

m := &autocert.Manager{
Cache:      autocert.DirCache("golang-autocert"),
Prompt:     autocert.AcceptTOS,
HostPolicy: autocert.HostWhitelist("example.org", "www.example.org"),
}
server := &http.Server{
    Addr:      ":443",
    TLSConfig: m.TLSConfig(),
}
server.ListenAndServeTLS("", "")

Haec facilis est via ad plenam HTTPS instrumenti confirmationem renovationis certificalis latae.

Addit consuetudo itinera

Defectus itineris in bibliotheca mensurae inclusus bonus est, sed valde fundamentalis est. Pleraque applicationes fuso multipliciores requirunt, inclusa itinera nidificata et wildcarda, vel ratio viae ad formas et parametri.

Hic valet uti packages muta/mux и ire-chi / chi. Cum hoc opere discemus — exemplum infra ostendetur.

Data est tabella api/v1/api.go continens itinera nostra API:

/ HelloResponse is the JSON representation for a customized message
type HelloResponse struct {
Message string `json:"message"`
}
 
// HelloName returns a personalized JSON message
func HelloName(w http.ResponseWriter, r *http.Request) {
name := chi.URLParam(r, "name")
response := HelloResponse{
Message: fmt.Sprintf("Hello %s!", name),
}
jsonResponse(w, response, http.StatusOK)
}
 
// NewRouter returns an HTTP handler that implements the routes for the API
func NewRouter() http.Handler {
r := chi.NewRouter()
r.Get("/{name}", HelloName)
return r
}

Praepositionem api/vq viae in tabula principali constituimus.

Hoc deinde conscendere possumus ad iter nostrum principale sub api/v1/ praepositione retro in applicatione principali nostro:

// NewRouter returns a new HTTP handler that implements the main server routes
func NewRouter() http.Handler {
router := chi.NewRouter()
    router.Mount("/api/v1/", v1.NewRouter())
    return router
}
http.Serve(autocert.NewListener("example.com"), NewRouter())

Facilitas ite laborandi per vias implicatas efficit ut faciliorem reddant structuram et sustentationem applicationum amplium et complexorum.

Working cum middleware

Choragium involvit unum tractatorem HTTP cum alio involvit, faciens ut celeriter authenticas, compressiones, colligationem et plura alia munera conficere possit.

Exemplum, inspiciamus http.Handler interface, ea scribenda manubrio utemur, qui ministerium utentium authenticat.

func RequireAuthentication(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if !isAuthenticated(r) {
            http.Redirect(w, r, "/login", http.StatusTemporaryRedirect)
            return
        }
        // Assuming authentication passed, run the original handler
        next.ServeHTTP(w, r)
    })
}

Iterarum partium tertiae sunt, ut chi, qui te medias functiones medias extendere permittunt.

Operantes cum static files

The Go standard library includes capacities for working with static content, including images, JavaScript and CSS files. Possunt accessi per munus http.FileServer. Redit tracto qui lima ex certae indicis inservit.

func NewRouter() http.Handler {
    router := chi.NewRouter()
    r.Get("/{name}", HelloName)
 
// Настройка раздачи статических файлов
staticPath, _ := filepath.Abs("../../static/")
fs := http.FileServer(http.Dir(staticPath))
    router.Handle("/*", fs)
    
    return r

Prorsus memoria dignum est quod http.Dir contenta indicem ostentat si documentum principale non continet.html. Hoc in casu, ne directorium impediretur, sarcina uti debetis unindexed.

Verum shutdown

Ite etiam plumam lepidam appellatam shutdown servo HTTP. Hoc fieri potest utendo methodo Shutdown. Servus in goroutine incipit, et tunc canalis auditur ut signum interrumperet. Statim ac signum recipitur, minister se vertit, sed non statim, sed post brevi.

handler := server.NewRouter()
srv := &http.Server{
    Handler: handler,
}
 
go func() {
srv.Serve(autocert.NewListener(domains...))
}()
 
// Wait for an interrupt
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
<-c
 
// Attempt a graceful shutdown
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
srv.Shutdown(ctx)

Ad summam:

Ire lingua potens est cum bibliotheca vexillum fere universale. Eius defectus facultates amplissimae sunt, et augeri possunt usura interfaces - id permittit ut vere certos HTTP servers enucleare sinat.

Skillbox commendat:

Duo annorum cursum "Pro elit sum".

Educational online course "Professio Java Developer".

Cursus practicus "PHP elit ab 0 ad PRO".

Source: www.habr.com

Web server development in Golang - a simplici ad complexu