Skip to content

API integration

Cloud providers offer a wide range of tools to interact with their API's. Most importantly, every cloud provider offers a command line tool. With larger cloud providers this is often the better choice compared to their web interface. The cloud provider for the project work, Exoscale, offers a CLI for all major platforms.


The source code for this exercise is available on GitHub.

Using the CLI#

When basic scripting is required the CLI may entirely be enough for the task. For example, you can query the list of instances in an instace pool as follows:

exo instancepool show INSTANCE-POOL-NAME --output-format json

You can use this command to generate your service discovery JSON file. Similarly, you could change the instance pool size:

exo instancepool update test --size 5

Using Go#

When it comes to creating a web server the CLI solution usually goes out the window because it is quite hard to create a webserver that calls a shell script. (It involves creating a CGI script, which is an easy way to also create a security hole.) Go being a popular language for the cloud world many cloud providers offer an SDK for this language. It also has a built-in library for creating web servers which makes it ideal to receive webhooks and react on them.

As a first step for this exercise let's create a file called go.mod to enable Go module support. (If you are unfamiliar with Go you really, really don't want to write Go code without this.)


go 1.14

require v0.27.0

As you can see, we already pulled in the egoscale library. This is the SDK for Exoscale in Go.

Let's create a simple main.go that increases the size of an instance pool:

package main

import (


func main() {
    zoneId, err := egoscale.ParseUUID("zone-id-here")
    if err != nil {
        log.Fatalf("invalid zone ID (%v)", err)
    poolId, err := egoscale.ParseUUID("instance-pool-id-here")
    if err != nil {
        log.Fatalf("invalid pool ID (%v)", err)

    // Create a new client
    client := egoscale.NewClient("", "api-key-here", "secret-here")
    ctx := context.Background()

    //Request the current size of the instance pool
    resp, err := client.RequestWithContext(ctx, egoscale.GetInstancePool{
        ZoneID: zoneId,
        ID:     poolId,
    response := resp.(egoscale.GetInstancePoolResponse)
    if len(response.InstancePools) == 0 {
        log.Fatalf("instance pool not found")
    } else if len(response.InstancePools) > 1 {
        //This should never happen
        log.Fatalf("more than one instance pool returned")
    instancePool := response.InstancePools[0]

    //Resize the instance pool
    _, err = client.RequestWithContext(ctx, egoscale.ScaleInstancePool{
        ZoneID: zoneId,
        ID:     poolId,
        Size:   instancePool.Size + 1,
    if err != nil {
        log.Fatalf("Failed to increase instance pool size (%v)", err)

This little program will increase the instance pool size by 1. You can run it with go run main.go.


A second popular language for cloud programming is Python. Exoscale also has an SDK for Python.


The Python library for Exoscale currently does not work on Windows.

First, let's create a requirements.txt:


Then we can run pip install -r requirements.txt and then implement this simple program:

import exoscale

if __name__ == "__main__":
    exo = exoscale.Exoscale(api_key="api-key-here", api_secret="api-secret-here", config_file="")

    zone = exo.compute.get_zone("zone-name-here")

    ip = exo.compute.get_instance_pool("instance-pool-id-here", zone=zone)
    ip.scale(ip.size + 1)

That's it!

Other languages#

Like every cloud provider, Exoscale provides a well documented API. There are third party SDK's available for several languages:


We have not tested these SDKs. We recommend sticking to the officially supported languages and may not be able to help if you work with the unofficial libraries.