Οι εφαρμογές Ιστού που έχουν σχεδιαστεί ώστε να είναι οριζόντια επεκτάσιμη συχνά απαιτούν έναν ή περισσότερους κόμβους εξισορρόπησης φορτίου. Πρωταρχικός σκοπός τους είναι να διανέμουν την εισερχόμενη επισκεψιμότητα σε όλους τους διαθέσιμους διακομιστές ιστού με δίκαιο τρόπο. Η ικανότητα αύξησης της συνολικής χωρητικότητας μιας διαδικτυακής εφαρμογής απλώς με την αύξηση του αριθμού των κόμβων και η προσαρμογή του φορτιστή προσαρμογής σε αυτήν την αλλαγή μπορεί να αποδειχθεί εξαιρετικά χρήσιμη στην παραγωγή.

Το NGINX είναι ένας διακομιστής ιστού που προσφέρει δυνατότητες εξισορρόπησης φορτίου υψηλής απόδοσης, μεταξύ πολλών από τις άλλες δυνατότητές του. Ορισμένες από αυτές τις λειτουργίες είναι διαθέσιμες μόνο ως μέρος του μοντέλου συνδρομής τους, αλλά η έκδοση δωρεάν και ανοιχτού κώδικα εξακολουθεί να είναι πολύ πλούσια σε χαρακτηριστικά και συνοδεύεται από τις πιο βασικές δυνατότητες εξισορρόπησης φορτίου.

Απλοποιημένη εξισορρόπηση φορτίου NGINX με Loadcat Τιτίβισμα

Σε αυτό το σεμινάριο, θα διερευνήσουμε την εσωτερική μηχανική ενός πειραματικό εργαλείο που σας επιτρέπει να διαμορφώσετε την παρουσία NGINX εν κινήσει ώστε να λειτουργεί ως εξισορροπητής φορτίου, αφαιρώντας όλες τις λεπτές λεπτομέρειες των αρχείων διαμόρφωσης NGINX, παρέχοντας μια τακτοποιημένη διεπαφή χρήστη που βασίζεται στον Ιστό. Ο σκοπός αυτού του άρθρου είναι να δείξει πόσο εύκολο είναι να ξεκινήσετε να δημιουργείτε ένα τέτοιο εργαλείο. Αξίζει να σημειωθεί ότι το έργο Loadcat εμπνέεται σε μεγάλο βαθμό από το Linode's NodeBalancers .

NGINX, Servers και Upstreams

Μία από τις πιο δημοφιλείς χρήσεις του NGINX είναι τα αιτήματα αντίστροφης μεσολάβησης από πελάτες σε εφαρμογές διακομιστή ιστού. Παρόλο που οι εφαρμογές ιστού που αναπτύχθηκαν σε γλώσσες προγραμματισμού όπως το Node.js και το Go μπορούν να είναι αυτοδύναμοι διακομιστές διαδικτύου, έχοντας έναν αντίστροφο διακομιστή μεσολάβησης μπροστά από την πραγματική εφαρμογή διακομιστή παρέχει πολλά οφέλη. Ένα μπλοκ 'διακομιστή' για μια απλή υπόθεση χρήσης όπως αυτό σε ένα αρχείο διαμόρφωσης NGINX μπορεί να μοιάζει με αυτό:

server { listen 80; server_name example.com; location / { proxy_pass http://192.168.0.51:5000; } }

Αυτό θα έκανε το NGINX να ακούσει στη θύρα 80 για όλα τα αιτήματα που παραπέμπουν στο example.com και να περάσει καθένα από αυτά σε κάποια εφαρμογή διακομιστή ιστού που εκτελείται στο 192.168.0.51:5000. Θα μπορούσαμε επίσης να χρησιμοποιήσουμε τη διεύθυνση IP loopback 127.0.0.1 εδώ εάν ο διακομιστής εφαρμογών ιστού εκτελούσε τοπικά. Λάβετε υπόψη ότι το παραπάνω απόσπασμα δεν έχει κάποιες προφανείς τροποποιήσεις που χρησιμοποιούνται συχνά σε ρυθμίσεις αντίστροφης μεσολάβησης, αλλά διατηρείται έτσι για συντομία.

Τι γίνεται όμως αν θέλαμε να εξισορροπήσουμε όλα τα εισερχόμενα αιτήματα μεταξύ δύο παρουσιών του ίδιου διακομιστή εφαρμογών ιστού; Αυτό είναι όπου η οδηγία «ανάντη» γίνεται χρήσιμη. Στο NGINX, με την οδηγία «upstream», είναι δυνατό να οριστούν πολλοί κόμβοι back-end μεταξύ των οποίων το NGINX θα εξισορροπήσει όλα τα εισερχόμενα αιτήματα. Για παράδειγμα:

upstream nodes { server 192.168.0.51:5000; server 192.168.0.52:5000; } server { listen 80; server_name example.com; location / { proxy_pass http://nodes; } }

Παρατηρήστε πώς ορίσαμε ένα μπλοκ 'upstream', που ονομάζεται 'κόμβοι', που αποτελείται από δύο διακομιστές. Κάθε διακομιστής αναγνωρίζεται από μια διεύθυνση IP και τον αριθμό θύρας που ακούει. Με αυτό, το NGINX γίνεται εξισορροπητής φορτίου στην απλούστερη μορφή του. Από προεπιλογή, το NGINX θα διανέμει τα εισερχόμενα αιτήματα με τρόπο round-robin, όπου ο πρώτος θα πληροί τον πρώτο διακομιστή, ο δεύτερος στον δεύτερο διακομιστή, ο τρίτος στον πρώτο διακομιστή και ούτω καθεξής.

Ωστόσο, το NGINX έχει πολλά περισσότερα να προσφέρει όταν πρόκειται για εξισορρόπηση φορτίου. Σας επιτρέπει να ορίσετε βάρη για κάθε διακομιστή, να τα επισημάνετε ως προσωρινά μη διαθέσιμα, να επιλέξετε έναν διαφορετικό αλγόριθμο εξισορρόπησης (π.χ. υπάρχει ένας που λειτουργεί βάσει του κατακερματισμού IP του πελάτη) κ.λπ. Αυτές οι λειτουργίες και οι οδηγίες διαμόρφωσης είναι όλες τεκμηριωθεί όμορφα στο nginx.org . Επιπλέον, το NGINX επιτρέπει την αλλαγή των αρχείων διαμόρφωσης και την επαναφόρτωση εν κινήσει χωρίς σχεδόν καμία διακοπή.

Τα αρχεία διαμόρφωσης του NGINX και τα απλά αρχεία διαμόρφωσης το καθιστούν πολύ εύκολο να το προσαρμόσετε σε πολλές ανάγκες. Και μια πληθώρα μαθημάτων υπάρχει ήδη στο Διαδίκτυο που σας διδάσκει ακριβώς πώς να ρυθμίσετε το NGINX ως εξισορροπητής φορτίου.

Loadcat: Εργαλείο διαμόρφωσης NGINX

Υπάρχει κάτι συναρπαστικό για τα προγράμματα που αντί να κάνουν κάτι μόνοι τους, διαμορφώστε άλλα εργαλεία για να το κάνετε για αυτά. Δεν κάνουν πολύ περισσότερα από ό, τι ίσως παίρνουν τις εισόδους των χρηστών και δημιουργούν μερικά αρχεία. Τα περισσότερα από τα οφέλη που αποκομίζετε από αυτά τα εργαλεία είναι στην πραγματικότητα χαρακτηριστικά άλλων εργαλείων. Όμως, σίγουρα κάνουν τη ζωή εύκολη. Ενώ προσπαθούσα να εγκαταστήσω έναν εξισορροπητή φορτίου για ένα από τα δικά μου έργα, αναρωτήθηκα: γιατί να μην κάνω κάτι παρόμοιο για το NGINX και τις δυνατότητές του για εξισορρόπηση φορτίου;

Φορτίο γεννήθηκε!

Loadcat, χτισμένο με Πηγαίνω , είναι ακόμα στα σπάργανα. Αυτή τη στιγμή, το εργαλείο σάς επιτρέπει να διαμορφώσετε το NGINX μόνο για εξισορρόπηση φορτίου και τερματισμό SSL. Παρέχει μια απλή διαδικτυακή βάση GUI για τον χρήστη . Αντί να περπατάμε μεμονωμένα χαρακτηριστικά του εργαλείου, ας ρίξουμε μια ματιά σε αυτό που βρίσκεται από κάτω. Λάβετε υπόψη σας, εάν κάποιος απολαμβάνει να δουλεύει με αρχεία διαμόρφωσης NGINX με το χέρι, μπορεί να βρει μικρή αξία σε ένα τέτοιο εργαλείο.

Υπάρχουν μερικοί λόγοι πίσω από την επιλογή Go ως γλώσσα προγραμματισμού για αυτό. Ένα από αυτά είναι ότι το Go παράγει μεταγλωττισμένα δυαδικά αρχεία. Αυτό μας επιτρέπει να δημιουργήσουμε και να διανείμουμε ή να αναπτύξουμε το Loadcat ως μεταγλωττισμένο δυαδικό σε απομακρυσμένους διακομιστές χωρίς να ανησυχούμε για την επίλυση εξαρτήσεων. Κάτι που απλοποιεί πολύ τη διαδικασία εγκατάστασης. Φυσικά, το δυαδικό υποθέτει ότι το NGINX είναι ήδη εγκατεστημένο και υπάρχει ένα αρχείο μονάδας systemd για αυτό.

Σε περίπτωση που δεν είστε Πήγαινε μηχανικός , μην ανησυχείτε καθόλου. Πήγαινε είναι αρκετά εύκολο και διασκεδαστικό για να ξεκινήσετε. Επιπλέον, η ίδια η εφαρμογή είναι πολύ απλή και θα πρέπει να μπορείτε να παρακολουθείτε εύκολα.

Δομή

Τα εργαλεία Go build επιβάλλουν μερικούς περιορισμούς στον τρόπο με τον οποίο μπορείτε να δομήσετε την εφαρμογή σας και να αφήσετε τα υπόλοιπα στον προγραμματιστή. Στην περίπτωσή μας, έχουμε χωρίσει τα πράγματα σε μερικά πακέτα Go με βάση τους σκοπούς τους:

• cfg: φορτώνει, αναλύει και παρέχει τιμές διαμόρφωσης
• cmd / loadcat: κύριο πακέτο, περιέχει το σημείο εισόδου, μεταγλωττίζεται σε δυαδικό
• δεδομένα: περιέχει 'μοντέλα', χρησιμοποιεί ένα ενσωματωμένο κλειδί / αποθήκη τιμών για επιμονή
• γάτα: περιέχει βασικές λειτουργίες, π.χ. δημιουργία αρχείων διαμόρφωσης, μηχανισμού επαναφόρτωσης κ.λπ.
• ui: περιέχει πρότυπα, χειριστές διευθύνσεων URL κ.λπ.

Εάν ρίξουμε μια πιο προσεκτική ματιά στη δομή του πακέτου, ειδικά μέσα στο πακέτο αιλουροειδών, θα παρατηρήσουμε ότι όλος ο συγκεκριμένος κωδικός NGINX έχει διατηρηθεί σε ένα αιλουροειδές / nginx. Αυτό γίνεται έτσι ώστε να μπορούμε να διατηρούμε το υπόλοιπο της λογικής της εφαρμογής γενικά και να επεκτείνουμε την υποστήριξη για άλλους εξισορροπητές φορτίου (π.χ. HAProxy) στο μέλλον.

Σημείο εισόδου

Ας ξεκινήσουμε από το κύριο πακέτο για το Loadcat, που βρίσκεται στο 'cmd / loadcatd'. Η κύρια λειτουργία, σημείο εισόδου της εφαρμογής, κάνει τρία πράγματα.

func main() { fconfig := flag.String('config', 'loadcat.conf', '') flag.Parse() cfg.LoadFile(*fconfig) feline.SetBase(filepath.Join(cfg.Current.Core.Dir, 'out')) data.OpenDB(filepath.Join(cfg.Current.Core.Dir, 'loadcat.db')) defer data.DB.Close() data.InitDB() http.Handle('/api', api.Router) http.Handle('/', ui.Router) go http.ListenAndServe(cfg.Current.Core.Address, nil) // Wait for an “interrupt“ signal (Ctrl+C in most terminals) }

Για να διατηρήσετε τα πράγματα απλά και να διευκολύνετε την ανάγνωση του κώδικα, όλοι οι κωδικοί χειρισμού σφαλμάτων έχουν αφαιρεθεί από το παραπάνω απόσπασμα (και επίσης από τα αποσπάσματα αργότερα σε αυτό το άρθρο).

Όπως μπορείτε να πείτε από τον κώδικα, φορτώνουμε το αρχείο διαμόρφωσης με βάση τη γραμμή εντολών '-config' (η οποία είναι προεπιλεγμένη στο 'loadcat.conf' στον τρέχοντα κατάλογο). Στη συνέχεια, αρχικοποιούμε μερικά στοιχεία, δηλαδή το βασικό πακέτο αιλουροειδών και τη βάση δεδομένων. Τέλος, ξεκινάμε έναν διακομιστή ιστού για το διαδικτυακό GUI.

Διαμόρφωση

Η φόρτωση και ανάλυση του αρχείου διαμόρφωσης είναι ίσως το πιο εύκολο μέρος εδώ. Χρησιμοποιούμε το TOML για την κωδικοποίηση πληροφοριών διαμόρφωσης. Υπάρχει ένα τακτοποιημένο πακέτο ανάλυσης TOML για το Go. Χρειαζόμαστε πολύ λίγες πληροφορίες διαμόρφωσης από τον χρήστη και στις περισσότερες περιπτώσεις μπορούμε να προσδιορίσουμε τις λογικές προεπιλογές για αυτές τις τιμές. Το ακόλουθο δομ αντιπροσωπεύει τη δομή του αρχείου διαμόρφωσης:

struct { Core struct { Address string Dir string Driver string } Nginx struct { Mode string Systemd struct { Service string } } }

Και εδώ είναι το τυπικό αρχείο 'loadcat.conf':

[core] address=':26590' dir='/var/lib/loadcat' driver='nginx' [nginx] mode='systemd' [nginx.systemd] service='nginx.service'

Όπως μπορούμε να δούμε, υπάρχει μια ομοιότητα μεταξύ της δομής του αρχείου διαμόρφωσης με κωδικοποίηση TOML και του δομ φαίνεται πάνω από αυτό. Το πακέτο διαμόρφωσης ξεκινά με τον ορισμό κάποιων προεπιλεγμένων λογικών για ορισμένα πεδία του δομ και στη συνέχεια αναλύει το αρχείο διαμόρφωσης πάνω του. Σε περίπτωση που δεν εντοπίσει ένα αρχείο διαμόρφωσης στην καθορισμένη διαδρομή, δημιουργεί ένα και απορρίπτει πρώτα τις προεπιλεγμένες τιμές.

func LoadFile(name string) error { f, _ := os.Open(name) if os.IsNotExist(err) { f, _ = os.Create(name) toml.NewEncoder(f).Encode(Current) f.Close() return nil } toml.NewDecoder(f).Decode(&Current) return nil }

Δεδομένα και ανθεκτικότητα

Συναντώ Μπουλόνι . Ένα ενσωματωμένο κλειδί / κατάστημα αξίας γραμμένο σε καθαρό Go. Έρχεται ως ένα πακέτο με ένα πολύ απλό API, υποστηρίζει συναλλαγές εκτός κουτιού και είναι ενοχλητικά γρήγορα.

Μέσα στα δεδομένα πακέτων, έχουμε δομές που αντιπροσωπεύουν κάθε τύπο οντότητας. Για παράδειγμα, έχουμε:

type Balancer struct { Id bson.ObjectId Label string Settings BalancerSettings } type Server struct { Id bson.ObjectId BalancerId bson.ObjectId Label string Settings ServerSettings }

… Όπου μια παρουσία του Ισορροπητής αντιπροσωπεύει έναν εξισορροπητή φορτίου. Το Loadcat σας επιτρέπει αποτελεσματικά να εξισορροπήσετε τα αιτήματα για πολλές εφαρμογές ιστού μέσω μιας μοναδικής παρουσίας του NGINX. Κάθε εξισορροπητής μπορεί στη συνέχεια να έχει έναν ή περισσότερους διακομιστές πίσω του, όπου κάθε διακομιστής μπορεί να είναι ένας ξεχωριστός κόμβος back-end.

Δεδομένου ότι το Bolt είναι ένα κατάστημα κλειδιού-τιμής και δεν υποστηρίζει προηγμένα ερωτήματα βάσης δεδομένων, έχουμε λογική από την πλευρά της εφαρμογής που το κάνει για εμάς. Το Loadcat δεν προορίζεται για τη διαμόρφωση χιλιάδων ζυγοσταθμιστών με χιλιάδες διακομιστές σε καθένα από αυτά, οπότε φυσικά αυτή η αφελής προσέγγιση λειτουργεί πολύ καλά. Επίσης, το Bolt λειτουργεί με πλήκτρα και τιμές που είναι κομμάτια byte, και γι 'αυτό κωδικοποιούμε το BSON δομές πριν τα αποθηκεύσετε στο Bolt. Η υλοποίηση μιας συνάρτησης που ανακτά μια λίστα Ισορροπητές δομές από τη βάση δεδομένων φαίνεται παρακάτω:

func ListBalancers() ([]Balancer, error) { bals := []Balancer{} DB.View(func(tx *bolt.Tx) error { b := tx.Bucket([]byte('balancers')) c := b.Cursor() for k, v := c.First(); k != nil; k, v = c.Next() { bal := Balancer{} bson.Unmarshal(v, &bal) bals = append(bals, bal) } return nil }) return bals, nil }

Λίστα εξισορρόπησης Η συνάρτηση ξεκινά μια συναλλαγή μόνο για ανάγνωση, επαναλαμβάνει όλα τα κλειδιά και τις τιμές μέσα στον κάδο 'εξισορρόπησης', αποκωδικοποιεί κάθε τιμή σε μια παρουσία Ισορροπία δομή και τους επιστρέφει σε έναν πίνακα.

Η αποθήκευση ενός ζυγοσταθμιστή στον κάδο είναι σχεδόν εξίσου απλή:

func (l *Balancer) Put() error { if !l.Id.Valid() { l.Id = bson.NewObjectId() } if l.Label == '' { l.Label = 'Unlabelled' } if l.Settings.Protocol == 'https' { // Parse certificate details } else { // Clear fields relevant to HTTPS only, such as SSL options and certificate details } return DB.Update(func(tx *bolt.Tx) error { b := tx.Bucket([]byte('balancers')) p, err := bson.Marshal(l) if err != nil { return err } return b.Put([]byte(l.Id.Hex()), p) }) }

ο Βάζω Η συνάρτηση εκχωρεί ορισμένες προεπιλεγμένες τιμές σε ορισμένα πεδία, αναλύει το συνημμένο πιστοποιητικό SSL στη ρύθμιση HTTPS, ξεκινά μια συναλλαγή, κωδικοποιεί το δομ παρουσία και το αποθηκεύει στον κάδο με το αναγνωριστικό του εξισορροπητή.

Κατά την ανάλυση του πιστοποιητικού SSL, δύο κομμάτια πληροφοριών εξάγονται χρησιμοποιώντας τυπική κωδικοποίηση πακέτου / pem και αποθηκεύτηκε σε Επιλογές SSL σύμφωνα με το Ρυθμίσεις πεδίο: τα ονόματα DNS και το δακτυλικό αποτύπωμα.

Έχουμε επίσης μια λειτουργία που αναζητά διακομιστές ανά εξισορρόπηση:

func ListServersByBalancer(bal *Balancer) ([]Server, error) { srvs := []Server{} DB.View(func(tx *bolt.Tx) error { b := tx.Bucket([]byte('servers')) c := b.Cursor() for k, v := c.First(); k != nil; k, v = c.Next() { srv := Server{} bson.Unmarshal(v, &srv) if srv.BalancerId.Hex() != bal.Id.Hex() { continue } srvs = append(srvs, srv) } return nil }) return srvs, nil }

Αυτή η συνάρτηση δείχνει πόσο αφελής είναι η προσέγγισή μας. Εδώ, διαβάζουμε αποτελεσματικά ολόκληρο τον κάδο 'διακομιστές' και φιλτράρουμε τις άσχετες οντότητες πριν επιστρέψουμε τον πίνακα. Αλλά και πάλι, αυτό λειτουργεί καλά, και δεν υπάρχει πραγματικός λόγος να το αλλάξουμε.

ο Βάζω Η λειτουργία για διακομιστές είναι πολύ απλούστερη από αυτήν Ισορροπία δομή καθώς δεν απαιτεί τόσες γραμμές προεπιλογών ρύθμισης κώδικα και πεδίων υπολογισμού.

Έλεγχος NGINX

Πριν χρησιμοποιήσουμε το Loadcat, πρέπει να ρυθμίσουμε το NGINX για να φορτώσουμε τα παραγόμενα αρχεία διαμόρφωσης. Το Loadcat δημιουργεί ένα αρχείο 'nginx.conf' για κάθε εξισορροπητή κάτω από έναν κατάλογο με το ID του εξισορροπητή (μια σύντομη εξαγωνική συμβολοσειρά). Αυτοί οι κατάλογοι δημιουργούνται κάτω από έναν κατάλογο «έξω» στο cwd. Επομένως, είναι σημαντικό να ρυθμίσετε το NGINX ώστε να φορτώνει αυτά τα δημιουργημένα αρχεία διαμόρφωσης. Αυτό μπορεί να γίνει χρησιμοποιώντας μια οδηγία 'συμπερίληψη' μέσα στο μπλοκ 'http':

Επεξεργαστείτε το /etc/nginx/nginx.conf και προσθέστε την ακόλουθη γραμμή στο τέλος του μπλοκ 'http':

http { include /path/to/out/*/nginx.conf; }

Αυτό θα κάνει το NGINX να σαρώσει όλους τους καταλόγους που βρίσκονται στο '/ path / to / out /', να αναζητήσει αρχεία με το όνομα 'nginx.conf' μέσα σε κάθε κατάλογο και να φορτώσει καθένα από αυτόν που βρίσκει.

Στο βασικό μας πακέτο, feline, ορίζουμε μια διεπαφή Οδηγός . Οποιος δομ που παρέχει δύο λειτουργίες, Παράγω και Φορτώνω πάλι , με τη σωστή υπογραφή χαρακτηρίζεται ως πρόγραμμα οδήγησης.

type Driver interface { Generate(string, *data.Balancer) error Reload() error }

Για παράδειγμα, η δομή Nginx κάτω από τα πακέτα γάτας / nginx:

type Nginx struct { sync.Mutex Systemd *dbus.Conn } func (n Nginx) Generate(dir string, bal *data.Balancer) error { // Acquire a lock on n.Mutex, and release before return f, _ := os.Create(filepath.Join(dir, 'nginx.conf')) TplNginxConf.Execute(f, /* template parameters */) f.Close() if bal.Settings.Protocol == 'https' { // Dump private key and certificate to the output directory (so that Nginx can find them) } return nil } func (n Nginx) Reload() error { // Acquire a lock on n.Mutex, and release before return switch cfg.Current.Nginx.Mode { case 'systemd': if n.Systemd == nil { c, err := dbus.NewSystemdConnection() n.Systemd = c } ch := make(chan string) n.Systemd.ReloadUnit(cfg.Current.Nginx.Systemd.Service, 'replace', ch) <-ch return nil default: return errors.New('unknown Nginx mode') } }

Παράγω μπορεί να κληθεί με μια συμβολοσειρά που περιέχει τη διαδρομή προς τον κατάλογο εξόδου και ένα δείκτη προς ένα Ισορροπητής περίσταση. Το Go παρέχει ένα τυπικό πακέτο για templating κειμένου, το οποίο χρησιμοποιεί το πρόγραμμα οδήγησης NGINX για τη δημιουργία του τελικού αρχείου διαμόρφωσης NGINX. Το πρότυπο αποτελείται από ένα μπλοκ 'upstream' ακολουθούμενο από ένα μπλοκ 'διακομιστή', που δημιουργείται με βάση τον τρόπο διαμόρφωσης του εξισορροπητή:

var TplNginxConf = template.Must(template.New('').Parse(` upstream {{.Balancer.Id.Hex}} { {{if eq .Balancer.Settings.Algorithm 'least-connections'}} least_conn; {{else if eq .Balancer.Settings.Algorithm 'source-ip'}} ip_hash; {{end}} {{range $srv := .Balancer.Servers}} server {{$srv.Settings.Address}} weight={{$srv.Settings.Weight}} {{if eq $srv.Settings.Availability 'available'}}{{else if eq $srv.Settings.Availability 'backup'}}backup{{else if eq $srv.Settings.Availability 'unavailable'}}down{{end}}; {{end}} } server { {{if eq .Balancer.Settings.Protocol 'http'}} listen {{.Balancer.Settings.Port}}; {{else if eq .Balancer.Settings.Protocol 'https'}} listen {{.Balancer.Settings.Port}} ssl; {{end}} server_name {{.Balancer.Settings.Hostname}}; {{if eq .Balancer.Settings.Protocol 'https'}} ssl on; ssl_certificate {{.Dir}}/server.crt; ssl_certificate_key {{.Dir}}/server.key; {{end}} location / { proxy_set_header Host $host; proxy_set_header X-Real-IP $remote_addr; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_set_header X-Forwarded-Proto $scheme; proxy_pass http://{{.Balancer.Id.Hex}}; proxy_http_version 1.1; proxy_set_header Upgrade $http_upgrade; proxy_set_header Connection 'upgrade'; } } `))

Φορτώνω πάλι είναι η άλλη λειτουργία Nginx δομή που κάνει το NGINX να φορτώσει ξανά τα αρχεία ρυθμίσεων. Ο μηχανισμός που χρησιμοποιείται βασίζεται στον τρόπο διαμόρφωσης του Loadcat. Από προεπιλογή, υποθέτει ότι το NGINX είναι μια υπηρεσία systemd που λειτουργεί ως nginx.service, έτσι ώστε [sudo] systemd reload nginx.service θα δούλευε. Ωστόσο, αντί να εκτελεί μια εντολή κελύφους, δημιουργεί μια σύνδεση με το systemd μέσω του D-Bus χρησιμοποιώντας το πακέτο github.com/coreos/go-systemd/dbus .

GUI που βασίζεται στον Ιστό

Με όλα αυτά τα στοιχεία στη θέση τους, θα τα ολοκληρώσουμε με ένα απλό περιβάλλον εργασίας χρήστη Bootstrap.

Λειτουργίες εξισορρόπησης φορτίου NGINX, τυλιγμένες σε ένα απλό GUI Τιτίβισμα

Για αυτές τις βασικές λειτουργίες, αρκούν μερικοί απλοί χειριστές διαδρομής GET και POST:

GET /balancers GET /balancers/new POST /balancers/new GET /balancers/{id} GET /balancers/{id}/edit POST /balancers/{id}/edit GET /balancers/{id}/servers/new POST /balancers/{id}/servers/new GET /servers/{id} GET /servers/{id}/edit POST /servers/{id}/edit

Η μετάβαση σε κάθε μεμονωμένη διαδρομή μπορεί να μην είναι το πιο ενδιαφέρον πράγμα που πρέπει να κάνετε εδώ, καθώς αυτές είναι σχεδόν οι σελίδες CRUD. Μη διστάσετε να ρίξετε μια ματιά στο κωδικός ui πακέτου για να δείτε πώς έχουν εφαρμοστεί χειριστές για καθεμία από αυτές τις διαδρομές.

Κάθε λειτουργία χειριστή είναι μια ρουτίνα που είτε:

• Ανακτά δεδομένα από την αποθήκευση δεδομένων και αποκρίνεται με πρότυπα που αποδίδονται (χρησιμοποιώντας τα δεδομένα ανάκτησης)
• Αναλύει τα εισερχόμενα δεδομένα φόρμας, κάνει τις απαραίτητες αλλαγές στο χώρο αποθήκευσης δεδομένων και χρησιμοποιεί το feline πακέτου για την αναγέννηση των αρχείων διαμόρφωσης NGINX

Για παράδειγμα:

func ServeServerNewForm(w http.ResponseWriter, r *http.Request) { vars := mux.Vars(r) bal, _ := data.GetBalancer(bson.ObjectIdHex(vars['id'])) TplServerNewForm.Execute(w, struct { Balancer *data.Balancer }{ Balancer: bal, }) } func HandleServerCreate(w http.ResponseWriter, r *http.Request) { vars := mux.Vars(r) bal, _ := data.GetBalancer(bson.ObjectIdHex(vars['id'])) r.ParseForm() body := struct { Label string `schema:'label'` Settings struct { Address string `schema:'address'` } `schema:'settings'` }{} schema.NewDecoder().Decode(&body, r.PostForm) srv := data.Server{} srv.BalancerId = bal.Id srv.Label = body.Label srv.Settings.Address = body.Settings.Address srv.Put() feline.Commit(bal) http.Redirect(w, r, '/servers/'+srv.Id.Hex()+'/edit', http.StatusSeeOther) }

Ολα ServeServerNewForm Η λειτουργία κάνει είναι να πάρει έναν εξισορροπητή από το κατάστημα δεδομένων και να κάνει ένα πρότυπο, Λίστα TplServer σε αυτήν την περίπτωση, η οποία ανακτά τη λίστα των σχετικών διακομιστών χρησιμοποιώντας το Διακομιστές λειτουργία στον εξισορροπητή.

HandleServerCreate Η συνάρτηση, εκτός από, αναλύει το εισερχόμενο ωφέλιμο φορτίο POST από το σώμα σε ένα δομ και χρησιμοποιεί αυτά τα δεδομένα για να δημιουργήσει και να διατηρήσει ένα νέο Δομή διακομιστή στο datastore πριν χρησιμοποιήσετε το feline πακέτου για να δημιουργήσετε ξανά το αρχείο διαμόρφωσης NGINX για τον εξισορροπητή.

Όλα τα πρότυπα σελίδων αποθηκεύονται στο αρχείο 'ui / templates.go' και τα αντίστοιχα αρχεία HTML προτύπου βρίσκονται στον κατάλογο 'ui / templates'.

Δοκιμάστε το

Η ανάπτυξη του Loadcat σε έναν απομακρυσμένο διακομιστή ή ακόμα και στο τοπικό σας περιβάλλον είναι εξαιρετικά εύκολη. Εάν χρησιμοποιείτε Linux (64bit), μπορείτε να πάρετε ένα αρχείο με ένα προ-ενσωματωμένο δυαδικό Loadcat από το αποθετήριο Ενότητα εκδόσεων . Εάν αισθάνεστε λίγο τολμηροί, μπορείτε να κλωνοποιήσετε το αποθετήριο και να συντάξετε τον κώδικα μόνοι σας. Ωστόσο, η εμπειρία σε αυτήν την περίπτωση μπορεί να είναι λίγο απογοητευτικός καθώς η κατάρτιση προγραμμάτων Go δεν είναι πραγματικά μια πρόκληση. Και σε περίπτωση που τρέχετε το Arch Linux, τότε είστε τυχεροί! Κατασκευάστηκε ένα πακέτο για τη διανομή για ευκολία. Απλά Κατέβασέ το και εγκαταστήστε το χρησιμοποιώντας τον διαχειριστή πακέτων. Τα βήματα που περιλαμβάνονται περιγράφονται σε περισσότερες λεπτομέρειες στο έργο Αρχείο README.md .

Μόλις διαμορφώσετε και εκτελέσετε το Loadcat, τοποθετήστε το πρόγραμμα περιήγησής σας στο 'http: // localhost: 26590' (υποθέτοντας ότι εκτελείται τοπικά και ακούει στη θύρα 26590). Στη συνέχεια, δημιουργήστε έναν εξισορροπητή, δημιουργήστε μερικούς διακομιστές, βεβαιωθείτε ότι κάτι ακούει σε αυτές τις καθορισμένες θύρες και voila θα πρέπει να έχετε εισερχόμενα αιτήματα ισορροπίας φορτίου NGINX μεταξύ αυτών των διακομιστών που εκτελούνται.

Τι έπεται?

Αυτό το εργαλείο απέχει πολύ από το τέλειο, και στην πραγματικότητα είναι αρκετά πειραματικό έργο. Το εργαλείο δεν καλύπτει καν όλες τις βασικές λειτουργίες του NGINX. Για παράδειγμα, εάν θέλετε να αποθηκεύσετε προσωρινά τα στοιχεία που εξυπηρετούνται από τους κόμβους back-end στο επίπεδο NGINX, θα πρέπει να τροποποιήσετε τα αρχεία διαμόρφωσης NGINX με το χέρι. Και αυτό είναι που κάνει τα πράγματα συναρπαστικά. Υπάρχουν πολλά που μπορούν να γίνουν εδώ και αυτό ακριβώς ακολουθεί: καλύπτοντας ακόμη περισσότερες από τις λειτουργίες εξισορρόπησης φορτίων του NGINX - τις βασικές και πιθανώς ακόμη και αυτές που προσφέρει το NGINX Plus.

Δοκιμάστε το Loadcat. Ελέγξτε τον κωδικό, πιείτε τον, αλλάξτε τον, παίξτε μαζί του. Επίσης, ενημερώστε μας εάν έχετε δημιουργήσει ένα εργαλείο που διαμορφώνει άλλο λογισμικό ή έχετε χρησιμοποιήσει αυτό που πραγματικά σας αρέσει στην παρακάτω ενότητα σχολίων.