QuotaGuard

https://www.quotaguard.com/docs
Admin
QuotaGuard is a static IP proxy service that provides reliable fixed IP addresses to route and...
Tokens:265,223
Snippets:2,479
Trust Score:9
Update:3 weeks ago
Show doc for...
Tokens:
Raw
### Install golang.org/x/net/proxy

Source: https://www.quotaguard.com/docs/databases/postgresql/supabase-network-restrictions

Install the Go SOCKS5 proxy package required for the pgx example.

```bash
go get golang.org/x/net/proxy
```

--------------------------------

### Install pg and socks

Source: https://www.quotaguard.com/docs/databases/postgresql/supabase-network-restrictions

Install the pg and socks packages required for the Node.js example.

```bash
npm install pg socks
```

--------------------------------

### Node.js: Install pg and socks packages

Source: https://www.quotaguard.com/docs/databases/postgresql/neon-ip-allow

Installs the pg client and socks library required for the custom stream example.

```bash
npm install pg socks

```

--------------------------------

### Install undici

Source: https://www.quotaguard.com/docs/platforms/emergent/emergent-integration

Install the undici package, which is required for the native fetch example.

```bash
npm install undici

```

--------------------------------

### Go: Install golang.org/x/net/proxy package

Source: https://www.quotaguard.com/docs/databases/mongodb/atlas-integration

Command to install the Go proxy package required for the SOCKS5 dialer example.

```bash
go get golang.org/x/net/proxy

```

--------------------------------

### Run Application Under QGTunnel - Render Start Command

Source: https://www.quotaguard.com/docs/databases/postgresql/supabase-network-restrictions

Render start command to run the application under QGTunnel.

```bash
bin/qgtunnel npm start

```

--------------------------------

### Ruby: Install mongo and socksify gems

Source: https://www.quotaguard.com/docs/databases/mongodb/atlas-integration

Installs the mongo and socksify gems needed for the Ruby MongoDB SOCKS proxy example.

```bash
gem install mongo socksify

```

--------------------------------

### Wrap Retool start command with qgtunnel

Source: https://www.quotaguard.com/docs/platforms/retool/retool-integration

Use this command to start Retool with QGTunnel. It wraps the original start command so that database connections are intercepted and routed through QuotaGuard static IPs.

```bash
/app/bin/qgtunnel node_modules/.bin/retool-start
```

--------------------------------

### Example output when restrictions not applied

Source: https://www.quotaguard.com/docs/databases/postgresql/supabase-network-restrictions

Example output from the get command when restrictions have never been applied. The allowed CIDR list is empty and restrictions were not applied successfully, meaning all addresses can connect.

```plaintext
DB Allowed CIDRs: []
Restrictions applied successfully: false
```

--------------------------------

### Prefix Procfile start command with bin/qgtunnel

Source: https://www.quotaguard.com/docs/platforms/gigalixir/gigalixir-integration

Gigalixir reads the Procfile to start the app. Prefixing with bin/qgtunnel starts the tunnel before the app.

```procfile
web: bin/qgtunnel bin/my_app start

```

--------------------------------

### Install QGTunnel in Dockerfile

Source: https://www.quotaguard.com/docs/platforms/retool/retool-integration

Add this line to your Dockerfile to install the QGTunnel binary. It downloads and extracts the latest qgtunnel tarball to /app/bin.

```dockerfile
RUN curl https://s3.amazonaws.com/quotaguard/qgtunnel-latest.tar.gz | tar xz -C /app/bin
```

--------------------------------

### Procfile: Prefix start command with QGTunnel

Source: https://www.quotaguard.com/docs/platforms/scalingo/scalingo-integration

Prefix the normal start command with bin/qgtunnel in the Procfile to route traffic through the tunnel.

```procfile
web: bin/qgtunnel <your normal start command>
```

--------------------------------

### Original Procfile Startup Command

Source: https://www.quotaguard.com/docs/protocols/smtp/heroku-tunnel-setup

Example of a Procfile before adding QGTunnel. Replace 'your-application your arguments' with your actual startup command.

```text
web: your-application your arguments
```

--------------------------------

### Install https-proxy-agent for Node.js

Source: https://www.quotaguard.com/docs/platforms/aws/lambda-integration

Command to install the required https-proxy-agent package for the Node.js examples.

```bash
npm install https-proxy-agent

```

--------------------------------

### Run application under QGTunnel (local/generic, Heroku, Render, Railway, Fly.io, Docker, Kubernetes)

Source: https://www.quotaguard.com/docs/databases/redis/redis-cloud-cidr-allow-list

Shows how to launch your app under QGTunnel on various platforms. Each example uses 'bin/qgtunnel' as the entrypoint. For Heroku, the Procfile uses two lines for web and worker processes. For Docker and Kubernetes, the container spec must have qgtunnel as the entrypoint.

```bash
bin/qgtunnel node server.js
```

```text
web: bin/qgtunnel node server.js
worker: bin/qgtunnel node worker.js
```

```text
bin/qgtunnel npm start
```

```text
bin/qgtunnel npm start
```

```text
[processes]
  app = "bin/qgtunnel npm start"
```

```dockerfile
ENTRYPOINT ["/app/bin/qgtunnel"]
CMD ["node", "server.js"]
```

```yaml
command: ["/app/bin/qgtunnel"]
args: ["node", "server.js"]
```

--------------------------------

### Update Procfile to Use QGTunnel

Source: https://www.quotaguard.com/docs/databases/mariadb/direct-tunnel-setup

Before and after examples of a Procfile startup command. Prepend 'bin/qgtunnel' to your existing startup command to route traffic through the tunnel.

```text
web: your-application your arguments
```

```text
web: bin/qgtunnel your-application your arguments
```

--------------------------------

### Start n8n with QGTunnel

Source: https://www.quotaguard.com/docs/automation/n8n-integration

Starts n8n with QGTunnel as the entrypoint, enabling SOCKS5 proxying for database connections. Use this command on a self-hosted n8n instance after configuring the tunnel.

```bash
bin/qgtunnel n8n start

```

--------------------------------

### Download qgtunnel and force-add libnss_wrapper.so

Source: https://www.quotaguard.com/docs/troubleshooting/nss-wrapper-missing-so-file

Commands to download and extract qgtunnel into the project root, then force-add the missing .so file to Git because Git skips .so files by default.

```bash
curl https://s3.amazonaws.com/quotaguard/qgtunnel-latest.tar.gz | tar xz
```

```bash
git add -f vendor/nss_wrapper/libnss_wrapper.so
```

--------------------------------

### Node.js Explicit Proxy Configuration with https-proxy-agent

Source: https://www.quotaguard.com/docs/platforms/kubernetes/kubernetes-integration

Node.js does not automatically respect proxy environment variables. This example shows explicit configuration using the https-proxy-agent package. Install the agent with `npm install https-proxy-agent`.

```javascript
const axios = require('axios');
const { HttpsProxyAgent } = require('https-proxy-agent');

const proxyUrl = process.env.QUOTAGUARDSTATIC_URL;
const agent = new HttpsProxyAgent(proxyUrl);

axios.get('https://api.example.com/data', { httpsAgent: agent })
  .then(response => console.log(response.data))
  .catch(error => console.error(error));

```

--------------------------------

### Elixir Finch with QuotaGuard Proxy

Source: https://www.quotaguard.com/docs/platforms/fly-io/fly-io-integration

Configures Finch with the QuotaGuard proxy by starting a Finch pool with proxy connection options and proxy authorization headers. The example includes starting the pool and making a request.

```elixir
# In your application supervision tree
proxy_url = System.get_env("QUOTAGUARDSTATIC_URL")
uri = URI.parse(proxy_url)
[username, password] = String.split(uri.userinfo, ":")

Finch.start_link(
  name: MyFinch,
  pools: %{
    :default => [
      conn_opts: [
        proxy: {:http, uri.host, uri.port, []},
        proxy_headers: [
          {"proxy-authorization", "Basic " <> Base.encode64("#{username}:#{password}")}
        ]
      ]
    ]
  }
)

# Making a request
Finch.build(:get, "https://api.example.com/data")
|> Finch.request(MyFinch)

```

--------------------------------

### Docker Configuration with QGTunnel

Source: https://www.quotaguard.com/docs/databases/mongodb/atlas-integration

Dockerfile instructions to run the application with QGTunnel as the entrypoint.

```dockerfile
ENTRYPOINT ["/app/bin/qgtunnel"]
CMD ["node", "server.js"]

```

--------------------------------

### Updated HTTPS URL with QGTunnel Port

Source: https://www.quotaguard.com/docs/protocols/https-tunneling/direct-tunnel-setup

Example URL after QGTunnel setup. The port 4443 is added to route traffic through the tunnel.

```text
https://hostname.for.your.server.com:4443/some/long/path?var=1&var2=3
```

--------------------------------

### Axios example for Netlify Function

Source: https://www.quotaguard.com/docs/platforms/netlify/netlify-integration

Use this Netlify Function (Node.js) to make proxied requests via QuotaGuard Static using Axios. Requires installing axios: `npm install axios`. The proxy URL is read from the `QUOTAGUARDSTATIC_URL` environment variable.

```JavaScript
// netlify/functions/axios-example.mjs
import axios from 'axios';
import { HttpsProxyAgent } from 'https-proxy-agent';

export default async (req, context) => {
  const proxyUrl = process.env.QUOTAGUARDSTATIC_URL;
  const agent = new HttpsProxyAgent(proxyUrl);

  try {
    const response = await axios.get('https://api.example.com/data', {
      httpsAgent: agent,
      headers: {
        'Authorization': `Bearer ${process.env.API_KEY}`
      }
    });

    return new Response(JSON.stringify(response.data), {
      headers: { 'Content-Type': 'application/json' }
    });
  } catch (error) {
    return new Response(
      JSON.stringify({ error: error.message }),
      { status: 500, headers: { 'Content-Type': 'application/json' } }
    );
  }
};

```

--------------------------------

### Sample .qgtunnel configuration file

Source: https://www.quotaguard.com/docs/qgtunnel/wildcard-hosts

Example of the .qgtunnel file format that must be created for dynamic tunnels. The file should be named like qgtunnel.12345 and placed in the .qgtunnels directory. The example shows local port 12345, hostname, and database port 3306.

```ini
[qgtunnel.12345]
accept = "localhost:12345"
connect = "hostname:3306"
transparent = true
```

--------------------------------

### Download QGTunnel into release overlay

Source: https://www.quotaguard.com/docs/platforms/gigalixir/gigalixir-integration

Creates the overlay directory and downloads QGTunnel into it so the tunnel binary ships inside the container.

```bash
mkdir -p rel/overlays/bin
curl https://s3.amazonaws.com/quotaguard/qgtunnel-latest.tar.gz | tar xz -C rel/overlays

```

--------------------------------

### Make proxied HTTP request in Scala with sttp

Source: https://www.quotaguard.com/docs/platforms/emergent/emergent-integration

Scala example using sttp client to make a synchronous HTTP GET through a proxy from the QUOTAGUARDSTATIC_URL environment variable. It sets a default Authenticator with credentials from the URL's userInfo and configures the backend with httpProxy options.

```scala
import sttp.client3._
import sttp.client3.httpclient.HttpClientSyncBackend
import java.net.{InetSocketAddress, PasswordAuthentication, Proxy, Authenticator}

object ProxiedClient {
  def call(url: String): String = {
    val proxyUrl = new java.net.URL(sys.env("QUOTAGUARDSTATIC_URL"))
    val userInfo = proxyUrl.getUserInfo.split(":")
    
    Authenticator.setDefault(new Authenticator {
      override def getPasswordAuthentication: PasswordAuthentication =
        new PasswordAuthentication(userInfo(0), userInfo(1).toCharArray)
    })
    
    val backend = HttpClientSyncBackend(
      options = SttpBackendOptions.httpProxy(proxyUrl.getHost, proxyUrl.getPort)
    )
    
    val request = basicRequest.get(uri"$url")
    val response = request.send(backend)
    
    response.body.getOrElse("")
  }
}
```

--------------------------------

### Configure Ruby SFTP with QuotaGuard HTTP proxy and list files

Source: https://www.quotaguard.com/docs/outbound-proxy/ruby/sftp-file-transfer

Use this example to route an SFTP transfer through QuotaGuard's static IP proxy. It reads proxy credentials from the QUOTAGUARDSTATIC_URL environment variable, creates an HTTP proxy, and then starts an SSH session to 1.1.1.1 as 'sftpuser'. The example then connects SFTP and iterates over the root directory, printing each entry's long name. The password 'sftppw' is shown as a placeholder; replace it with the actual password.

```ruby
require 'net/ssh'
require 'uri'
require 'net/sftp'
require 'net/ssh/proxy/http'
quotaguard = URI(ENV["QUOTAGUARDSTATIC_URL"])

proxy = Net::SSH::Proxy::HTTP.new(quotaguard.host,quotaguard.port, :user => quotaguard.user,:password=>quotaguard.password)

Net::SSH.start('1.1.1.1','sftpuser',
{:port => 22,
:proxy => proxy,
:password => 'sftppw'}) do |ssh|

ssh.sftp.connect do |sftp|
sftp.dir.foreach("/") do |entry|
puts entry.longname
end
end
end
```

--------------------------------

### Access HTTPS API with Node.js Request module

Source: https://www.quotaguard.com/docs/platforms/heroku/static-setup

Accesses an HTTPS API through the proxy using the Request module (npm install request). The standard Node.js HTTPS module does not handle proxy requests well, so this example uses the request library with the proxy option set to QUOTAGUARDSTATIC_URL.

```javascript
var request = require('request');

var options = {
    proxy: process.env.QUOTAGUARDSTATIC_URL,
    url: 'https://api.github.com/repos/joyent/node',
    headers: {
        'User-Agent': 'node.js'
    }
};

function callback(error, response, body) {   
    if (!error && response.statusCode == 200) {
        console.log(body);     
    }
}

request(options, callback);

```

--------------------------------

### Run Application Under QGTunnel - Fly.io fly.toml

Source: https://www.quotaguard.com/docs/databases/postgresql/supabase-network-restrictions

Fly.io configuration in fly.toml to run the application under QGTunnel.

```toml
[processes]
  app = "bin/qgtunnel npm start"

```

--------------------------------

### Direct PHP cURL proxied POST request with JSON body

Source: https://www.quotaguard.com/docs/platforms/pantheon/pantheon-integration

Sends a POST request with a JSON body through the QuotaGuard proxy using cURL. Sets Content-Type and Accept headers to application/json, uses the same proxy credentials and timeouts as the GET example, and throws an Exception on cURL errors.

```php
<?php
function make_proxied_post($url, $data) {
    $proxy_host = '<your-quotaguard-proxy-host>';
    $proxy_port = 9293;
    $proxy_user = 'your-quotaguard-username';
    $proxy_pass = 'your-quotaguard-password';
    
    $ch = curl_init();
    
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
    curl_setopt($ch, CURLOPT_HTTPHEADER, array(
        'Content-Type: application/json',
        'Accept: application/json'
    ));
    curl_setopt($ch, CURLOPT_PROXY, $proxy_host . ':' . $proxy_port);
    curl_setopt($ch, CURLOPT_PROXYUSERPWD, $proxy_user . ':' . $proxy_pass);
    curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 10);
    curl_setopt($ch, CURLOPT_TIMEOUT, 30);
    
    $response = curl_exec($ch);
    
    if (curl_errno($ch)) {
        $error = curl_error($ch);
        curl_close($ch);
        throw new Exception('cURL error: ' . $error);
    }
    
    curl_close($ch);
    return $response;
}

```

--------------------------------

### Create PEM bundle from key and certificate

Source: https://www.quotaguard.com/docs/platforms/heroku/static-setup

Create a PEM bundle containing the private key and certificate for use with stunnel.

```bash
$ cat example.com.key example.com.cer > example.com.pem

```

--------------------------------

### Direct PHP cURL proxied GET request

Source: https://www.quotaguard.com/docs/platforms/pantheon/pantheon-integration

Use for custom PHP code that doesn't use WordPress or Drupal's HTTP clients. Configures cURL with QuotaGuard proxy credentials and recommended timeouts, throws an Exception on cURL errors, and includes an example usage with error logging.

```php
<?php
/**
 * Makes a proxied HTTP request using cURL directly.
 */
function make_proxied_request($url) {
    $proxy_host = '<your-quotaguard-proxy-host>';
    $proxy_port = 9293;
    $proxy_user = 'your-quotaguard-username';
    $proxy_pass = 'your-quotaguard-password';
    
    $ch = curl_init();
    
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_PROXY, $proxy_host . ':' . $proxy_port);
    curl_setopt($ch, CURLOPT_PROXYUSERPWD, $proxy_user . ':' . $proxy_pass);
    
    // Recommended timeout settings
    curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 10);
    curl_setopt($ch, CURLOPT_TIMEOUT, 30);
    
    $response = curl_exec($ch);
    
    if (curl_errno($ch)) {
        $error = curl_error($ch);
        curl_close($ch);
        throw new Exception('cURL error: ' . $error);
    }
    
    curl_close($ch);
    return $response;
}

// Example usage
try {
    $result = make_proxied_request('https://api.example.com/data');
    $data = json_decode($result, true);
} catch (Exception $e) {
    error_log('Request failed: ' . $e->getMessage());
}

```

--------------------------------

### Original Heroku Procfile

Source: https://www.quotaguard.com/docs/qgtunnel/vpn-tunneling-setup

Example Procfile before modification, showing the original startup commands for web and worker processes.

```Procfile
web: npm start
worker: rails worker go

```

--------------------------------

### Python with Requests: proxy setup and POST request

Source: https://www.quotaguard.com/docs/platforms/emergent/emergent-integration

Uses the requests library with the QUOTAGUARDSTATIC_URL environment variable to configure proxies for both HTTP and HTTPS. The call_protected_api function sends a JSON POST request through the proxy and returns the response JSON. Includes an example sync_inventory function for a partner API behind a corporate firewall.

```python
import os
import requests

proxy_url = os.environ.get('QUOTAGUARDSTATIC_URL')

proxies = {
    'http': proxy_url,
    'https': proxy_url
}

def call_protected_api(url, data):
    response = requests.post(url, json=data, proxies=proxies)
    return response.json()

# Example: partner API behind corporate firewall
def sync_inventory(inventory_data):
    return call_protected_api(
        'https://api.partner.com/v2/inventory',
        inventory_data
    )

```

--------------------------------

### Go with net/http

Source: https://www.quotaguard.com/docs/platforms/replit/replit-integration

Creates an HTTP client with a proxy from the QUOTAGUARDSTATIC_URL environment variable. Uses net/http and net/url packages.

```go
package main

import (
    "fmt"
    "net/http"
    "net/url"
    "os"
)

func main() {
    proxyURL, _ := url.Parse(os.Getenv("QUOTAGUARDSTATIC_URL"))

    client := &http.Client{
        Transport: &http.Transport{
            Proxy: http.ProxyURL(proxyURL),
        },
    }

    resp, err := client.Get("https://api.example.com/data")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    fmt.Println("Status:", resp.Status)
}

```
Tokens:
Raw