Please enable JavaScript.

Coggle requires JavaScript to display documents.

Nginx and HAProxy (High Availability Proxy) (Nginx (Overview (Attributes,…

- - - - Full HTTP/2 proxy
      - Load balancing out of the box
  - - - Nginx divides configurrations meant to server different content into blocks
      - Each time a client request is made, Nginx begins a process of determining which configuration blocks should be used to handle the request
      - Two Main
        
        Server Block
        
        Server block is a subset of Nginx'x config that defines a virtual server used to handle requests of defined type
        
        Configure multiple server blocks and decide which block should handle which connections based on requested domain/post/IP Address
        
        main server block directives to
        route requests correctly
        
        listen
        
        Nginx looks at IP Address and Port and matches them up
        
        By default any server block that doesn't include the listen directive
        is given default parameters of 0.0.0.0:80
        
        Listen port can be set to: An IP Address a Port or a combo of the two
        
        When determining the server block to send a request to Nginx will go to the listen directive first and match the request up (including defaults)
        
        server_name
        
        If listen directive has 2+ matches Nginx will go to server_name directive to determine where the request goes. (Nginx will only evaluate server name if 2+ matches of listen directive)
        
        e.g. 2 sever blocks
        server{ listen:192.168.1.10}
        server{ listen:80 server_name example.com}
        Any requests for example.com (hosted on 192.168.1.10) will go to first server block
        
        Parsing server_name
        
        Comes under the $host header - which contains the domain/IP Address the client is trying to reach
        
        Nginx will try to match server_name together exactly - if found that block servers request - if multiple found - use first one
        
        If no exact match - Nginx will try to find server_name will use a * wildcard at start of $host
        
        Same as two but with * at end
        
        Try to match via regular expression - if this FAILS -> default block
        
        Location Block
        
        Overview
        
        Location blocks decide how to process the request URI
        
        Location block lives within server block and is used to define how Nginx should handle requests for different resources and URIs for the parent server - flexible model
        
        Generally, when a location block is selected to serve a request, the request is handled entirely within that context from that point onward - no sibling location blocks interfere
        
        Location Blocks Syntax
        
        location option_modifier location_match{ ... }
        
        location_match is what Nginx should the check the URI against
        
        Prefix e.g. location /site will always be used for URI with /site, /site/page1/index.html or /site/shabba/labba/ding/index.html
        
        If you want to match site/page1/index.html need to use exact modifier i.e. =
        
        This location block will match /tortoise.jpg but not /FLOWER.PNG (case sensitive)
        location ~ \.(jpe?g|png|gif|ico)${ ... }
        But will match with this:
        location ~* \.(jpe?g|png|gif|ico)${ ... }
        
        optional_modifier options
        
        none
        
        Prefix match - location will be matched against beginning of the URI
        
        ~
        
        Case-sensitive regular expression match
        
        =
        
        URI must exactly match
        
        ~*
        
        Location block will be case-insensitive regular expression match
        
        ^~
        
        Best non-regular expression match
        
        Match Algorithm
        
        Evaluates all location contexts by comparing request URI to each location
        
        Checks all prefix matches
        
        Looks for exact matches where = is used to match
        
        Evaluates non-exact prefixes
        Nginx will server regular expression matches in preference to prefix matches, however, it evaluates prefix matches first
        
        Prefix locations are matched 1st by the longest,most specific whilst regular expression match is stopped at the first matching location - so positioning within the config has an implication
        
        Can have "internal redirect" where matching happens again - when these directives are used
        index,try_files,rewrite,error_page
        
        index directive always lead to internal redirect if used to handle request.
        Exact location matches are used to speed up selection process, however, if exact location is directory you may need to redirect to a new location for processing
        
        try_files - tells Nginx to check for existence of a named set of files/directories - last param can be URI Nginx will redirect to
        root /var/www/main;
        location {
        try_files $uri $uri.html $uri/ /fallback/index.html; }
        location /fallback {
        root /var/www/another}
        If a request is made to /example - first location will get it -> it will then try to find a file called example in the main directory. If fails it tries to find example.html then looks for directory - if all fails goes to /fallback which will trigger another location search using fallback
        
        rewrite directive -> Nginx will search for new matching location based on the results of the rewrite
        Add this line to above try_files example in the line above try_filesrewrite ^/rewriteme/(.*)$ /$1 last;
        Any request coming into /rewriteme/hello will be handled by 1st block and will be rewritten to /hello and a location will be searched - which will match the / location again and will try_files hello, hello.html ....
        
        error_page directive is similar to try_files. It is used to define what should happen when certain status codes are encountered. This won't really be executed if try_files is set since try_files handles life cycle of a request.
        
        Matching Algo is important to know for performance reasons when high traffic - regular expression matches will hit performance
    - - Anything with { } is called contexts
      - Contexts can be inside each other - therefore if a directive is valid in multiple nested scopes, a declaration in a broader context will be passed to child contexts as default
        :star: The children contexts can overide these at will
      - Types
        
        Core - Contexts that comprise the major structure of an Nginx config
        
        Main/Global - the only context that is not contained within the typical context blocks.
        It is the boradest environment for Nginx config and affects the entire app.
        Directives here affect lower contexts many aren't inherited because they cannot be overridden.
        example directives: worker processes, default error file
        
        Events
        
        context is contained within Main context - used to set global options that affect how Nginx handles connections at a general level. There can one be 1 events context in config
        
        Nginx uses an event-baed connection processing model, so directives defined here determine how worker processes should handle connections
        
        Server
        
        Declared within the http context (nested) and can have multiple.
        Each context defines a specific virtual server to handle requests.
        
        2 directives used to decide if server block should handle request
        
        server_name - used to select server block for processing - if Listen has multiple matches will look at $host header of request and match it against server_name
        
        Listen - the IP/Port combo that the block should respond to
        
        Location
        
        Similar to server contexts - can have multiple, each location used to handle specific request
        
        They are defined in the line that opens the block
        location match_modifier location_match{ ...
        
        They live with server contexts and can be nested inside each other (unlike server blocks)
        location /other {
        location nested_match{ .. } }
        
        Defined by the request URI (the portion of the request that comes after the domain name/ IP address:Port Combo
        
        HTTP
        
        When configuring Nginx as a web server or reverse proxy "http" context will hold the config - defines how to handle HTTP/S connections
        
        Context is a sibling of events context and child of Main
        
        Controls the defaults for every virtual server via directives such as access_log,error_log,error_page,gzip,keepalive... requests
        
        Non-core
        
        Mail
        
        Defined within Main/Global context - outside of http
        
        Provides area for configure mail proxying solution on server. Nginx can redirect authentication requests to external authentication server - then provides access to POP3 and IMAP mail servers for serving data
        
        If
        
        Provides conditional processing of directives defined within.
        
        Don't use for most forms of conditional - have purpose built directives for it - if is evil
        
        Any try_files directive in if block is useless
        
        Limit_except
        
        Used to restrict certain HTTP methods within a location context
        limit_except GET HEAD{...
        
        Upstream
        
        Defines "upstream" servers - a pool of servers that Nginx can proxy requests to.
        
        Should be placed within the http context outside of specific server contexts
        
        Use round robin by default to determine specific server to hand request to - load balancing
        
        Optional/Used in certain circumstances
        
        Map - used to set the value of variable depending on value of another variable
        
        Geo - specify a mapping
        
        types - used for mapping MIME types to file extensions
      - General rule - declare directives in highest context possible - then override them when necessary in children
- - - - systemctl restart rsyslog
        systemctl start haproxy
      - Start HAProxy at Boot time
        systemctl enable haproxy
  - - - Good practice - go to /etc/hosts/ file and put alias with IP Address e.g 192.168.1.100 server_one
      - Change name of HAProxy server: sudo nano /etc/hostname
        change default to haproxy.local
      - Enable proxy to start at boot: sudo nano /etc/default/haproxy and add the following line under #CONFIG option ENABLED = 1
- - - - Nginx can load balance but not its primary focus (web server)
      - Not as good as HAProxy for metric reporting and alternative is expensive (Nginx Plus)
    - - HAProxy's primary service is to load balance and does it better
      - Comprehensive list of 61 different server metrics
      - Easy to integrate
    - - Load balancing is the distribution of data resources across multiple servers with the purpose of lightening the load of several requests across a cluster of servers
      - Types
        
        Roud Robin (for each new connected handle by a new server)
        
        IP Hash/Source - client IP will be hashed to determine that the same backend server serves the requests for a specific client
        
        Least Connections - the new connection is handled by the server with least amount of connections
      - Point of entrance to the datacenter - on the critical path to access everything
      - Most important thing to monitor and they are in unique position to give insights about the service and services they provide.
        HAProxy can integrate with monitoring solutions (e.g. datadog, signalfc,prometheus,graphite) very easily - Datadog the best option (can set up auto alerts)
    - - Use Nginx for the web server and HAProxy as load balancer
      - When traffic gets really heavy - put HAProxy infront of Nginx servers which have cached the website - monitor stats with Datadog and get auto email alerts