How to Scale Load Balancers

To scale a load balancer via the command-line, follow these steps:

1. Install doctl, the DigitalOcean command-line tool.

2. Create a personal access token, and save it for use with doctl.

3. Use the token to grant doctl access to your DigitalOcean account.

                 doctl auth init
               

4. Finally, scale a load balancer with doctl compute load-balancer update. The basic usage looks like this, but you'll want to read the usage docs for more details:

                 doctl compute load-balancer update <id> [flags]
               

To scale a load balancer using the DigitalOcean API, follow these steps:

1. Create a personal access token, and save it for use with the API.

2. Send a PUT request to https://api.digitalocean.com/v2/load_balancers/{lb_id}

   cURL

   To scale a load balancer with cURL, call:

   
                   curl -X PUT \
     -H "Content-Type: application/json" \
     -H "Authorization: Bearer $DIGITALOCEAN_TOKEN" \
     -d '{"name":"example-lb-01","size_unit":"2","region":"nyc3","algorithm":"least_connections","forwarding_rules":[{"entry_protocol":"http","entry_port":80,"target_protocol":"http","target_port":80},{"entry_protocol":"https","entry_port":444,"target_protocol":"https","target_port":443,"tls_passthrough":true}],"health_check":{"protocol":"http","port":80,"path":"/","check_interval_seconds":10,"response_timeout_seconds":5,"healthy_threshold":5,"unhealthy_threshold":3},"sticky_sessions":{"type":"cookies", "cookie_name": "DO_LB", "cookie_ttl_seconds": 300}, "droplet_ids": [3164444, 3164445]}' \
     "https://api.digitalocean.com/v2/load_balancers/4de7ac8b-495b-4884-9a69-1050c6793cd6"

   Go

   Go developers can use Godo, the official DigitalOcean V2 API client for Go. To scale a load balancer with Godo, use the following code:

   
                   import (
       "context"
       "os"
   
       "github.com/digitalocean/godo"
   )
   
   func main() {
       token := os.Getenv("DIGITALOCEAN_TOKEN")
   
       client := godo.NewFromToken(token)
       ctx := context.TODO()
   
       updateRequest := &godo.LoadBalancerRequest{
           Name:      "example-01",
           SizeUnit: "2",
           Algorithm: "round_robin",
           Region:    "nyc3",
           ForwardingRules: []godo.ForwardingRule{
               {
                   EntryProtocol:  "http",
                   EntryPort:      80,
                   TargetProtocol: "http",
                   TargetPort:     80,
               },
               {
                   EntryProtocol:  "https",
                   EntryPort:      443,
                   TargetProtocol: "https",
                   TargetPort:     443,
                   TlsPassthrough: true,
               },
           },
           HealthCheck: &godo.HealthCheck{
               Protocol:               "http",
               Port:                   80,
               Path:                   "/",
               CheckIntervalSeconds:   10,
               ResponseTimeoutSeconds: 5,
               HealthyThreshold:       5,
               UnhealthyThreshold:     3,
           },
           StickySessions: &godo.StickySessions{
               Type:             "cookies",
               CookieName:       "DO_LB",
               CookieTtlSeconds: 300,
           },
           DropletIDs:          []int{3164444, 3164445},
           RedirectHttpToHttps: false,
       }
   
       lb, _, err := c.LoadBalancers.Update(ctx, "c2c97ca7-6f63-4e23-8909-906fd86efb5e", updateRequest)
   }

   Ruby

   Ruby developers can use DropletKit, the official DigitalOcean V2 API client for Ruby. To scale a load balancer with DropletKit, use the following code:

   
                   require 'droplet_kit'
   token = ENV['DIGITALOCEAN_TOKEN']
   client = DropletKit::Client.new(access_token: token)
   
   load_balancer = DropletKit::LoadBalancer.new(
     name: 'example-lb-01',
     size_unit: '2',
     algorithm: 'round_robin',
     droplet_ids: [ 3164444, 3164445],
     redirect_http_to_https: true,
     region: 'nyc3',
     forwarding_rules: [
       DropletKit::ForwardingRule.new(
         entry_protocol: 'http',
         entry_port: 80,
         target_protocol: 'http',
         target_port: 80,
         certificate_id: '',
         tls_passthrough: false
       ),
       DropletKit::ForwardingRule.new(
         entry_protocol: 'https',
         entry_port: 443,
         target_protocol: 'https',
         target_port: 443,
         certificate_id: '',
         tls_passthrough: true
       )
     ],
     sticky_sessions: DropletKit::StickySession.new(
       type: 'cookies',
       cookie_name: 'DO-LB-COOKIE',
       cookie_ttl_seconds: 5
     ),
     health_check: DropletKit::HealthCheck.new(
       protocol: 'http',
       port: 80,
       path: '/',
       check_interval_seconds: 10,
       response_timeout_seconds: 5,
       healthy_threshold: 5,
       unhealthy_threshold: 3
     )
   )
   client.load_balancers.update(load_balancer, id: '4de7ac8b-495b-4884-9a69-1050c6793cd6')