How to Create Firewalls

To create a firewall 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, create a firewall with doctl compute firewall create. The basic usage looks like this, but you'll want to read the usage docs for more details:

                 doctl compute firewall create [flags]
               

   The following example creates a cloud firewall named example-firewall that contains an inbound rule and an outbound rule and applies them to the specified Droplet

                      doctl compute firewall create --name "example-firewall" --inbound-rules "protocol
                   

To create a firewall using the DigitalOcean API, follow these steps:

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

2. Send a POST request to https://api.digitalocean.com/v2/firewalls

   cURL

   To create a firewall with cURL, call:

   
                   curl -X POST \
     -H "Content-Type: application/json" \
     -H "Authorization: Bearer $DIGITALOCEAN_TOKEN" \
     -d '{"name":"firewall","inbound_rules":[{"protocol":"tcp","ports":"80","sources":{"load_balancer_uids": ["4de7ac8b-495b-4884-9a69-1050c6793cd6"]}},{"protocol": "tcp","ports": "22","sources":{"tags": ["gateway"],"addresses": ["18.0.0.0/8"]}}],"outbound_rules":[{"protocol":"tcp","ports":"80","destinations":{"addresses":["0.0.0.0/0","::/0"]}}],"droplet_ids":[8043964]}' \
     "https://api.digitalocean.com/v2/firewalls"

   Go

   Go developers can use Godo, the official DigitalOcean V2 API client for Go. To create a firewall 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()
   
       createRequest := &godo.FirewallRequest{
           Name: 'firewall',
           InboundRules: []godo.InboundRule{
               {
                   Protocol: 'tcp',
                   PortRange: '80',
                   Sources: &godo.Sources{
                       LoadBalancerUIDs: []string{'4de7ac8b-495b-4884-9a69-1050c6793cd6'},
                   },
               },
               {
                   Protocol:  'tcp',
                   PortRange: '22',
                   Sources: &godo.Sources{
                       Addresses: []string{'18.0.0.0/8'},
                       Tags: []string{'gateway'},
                   },
               },
           },
           OutboundRules: []godo.OutboundRule{
               {
                   Protocol: 'tcp',
                   PortRange: '80',
                   Destinations: &godo.Destinations{
                       Addresses: []string{'0.0.0.0/0', '::/0'},
                   },
               },
           },
           DropletIDs: []int{8043964},
       }
   
       firewall, req, err := client.Firewalls.Create(ctx, createRequest)
   }

   Ruby

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

   
                   require 'droplet_kit'
   token = ENV['DIGITALOCEAN_TOKEN']
   client = DropletKit::Client.new(access_token: token)
   
   firewall = DropletKit::Firewall.new(
     name: 'firewall',
     inbound_rules: [
       DropletKit::FirewallInboundRule.new(
         protocol: 'tcp',
         ports: '80',
         sources: {
           load_balancer_uids: ['4de7ac8b-495b-4884-9a69-1050c6793cd6']
         }
       ),
       DropletKit::FirewallInboundRule.new(
         protocol: 'tcp',
         ports: '22',
         sources: {
           tags: ['gateway'],
           addresses: ['18.0.0.0/8']
         }
       )
     ],
     outbound_rules: [
       DropletKit::FirewallOutboundRule.new(
         protocol: 'tcp',
         ports: '80',
         destinations: {
           addresses: ['0.0.0.0/0', '::/0'],
         }
       )
     ],
     droplet_ids: [8043964]
   )
   
   client.firewalls.create(firewall)

   Python

   
                   import os
   from pydo import Client
   
   client = Client(token=os.environ.get("DIGITALOCEAN_TOKEN"))
   
   req = {
     "name": "firewall",
     "inbound_rules": [
       {
         "protocol": "tcp",
         "ports": "80",
         "sources": {
           "load_balancer_uids": [
             "4de7ac8b-495b-4884-9a69-1050c6793cd6"
           ]
         }
       },
       {
         "protocol": "tcp",
         "ports": "22",
         "sources": {
           "tags": [
             "gateway"
           ],
           "addresses": [
             "18.0.0.0/8"
           ]
         }
       }
     ],
     "outbound_rules": [
       {
         "protocol": "tcp",
         "ports": "80",
         "destinations": {
           "addresses": [
             "0.0.0.0/0",
             "::/0"
           ]
         }
       }
     ],
     "droplet_ids": [
       8043964
     ]
   }
   
   resp = client.firewalls.create(body=req)