3DS OUTSCALE API v1.33.2

Welcome to the OUTSCALE API documentation.
The OUTSCALE API enables you to manage your resources in the OUTSCALE Cloud. This documentation describes the different actions available along with code examples.

Throttling: To protect against overloads, the number of identical requests allowed in a given time period is limited.
Brute force: To protect against brute force attacks, the number of failed authentication attempts in a given time period is limited.

Note that the OUTSCALE Cloud is compatible with Amazon Web Services (AWS) APIs, but there are differences in resource names between AWS and the OUTSCALE API.
You can also manage your resources using the Cockpit web interface.

An OpenAPI description of the OUTSCALE API is also available in this GitHub repository.

Endpoints

Terms of service. Email: support@outscale.com. License: BSD 3 Clause.

Authentication Schemes

Access Key/Secret Key

The main way to authenticate your requests to the OUTSCALE API is to use an access key and a secret key.
The mechanism behind this is based on AWS Signature Version 4, whose technical implementation details are described in Signature of API Requests.

In practice, the way to specify your access key and secret key depends on the tool or SDK you want to use to interact with the API.

For example, if you use OSC CLI:

1. You need to create an ~/.osc/config.json file to specify your access key, secret key, and the Region of your account.
2. You then specify the --profile option when executing OSC CLI commands.

For more information, see Installing and Configuring OSC CLI.

See the code samples in each section of this documentation for specific examples in different programming languages.
For more information about access keys, see About Access Keys.

If you try to sign requests with an invalid access key four times in a row, further authentication attempts will be prevented for 1 minute. This lockout time increases 1 minute every four failed attempts, for up to 10 minutes.

Login/Password

For certain API actions, you can also use basic authentication with the login (email address) and password of your TINA account.
This is useful only in special circumstances, for example if you do not know your access key/secret key and want to retrieve them programmatically.
In most cases, however, you can use the Cockpit web interface to retrieve them.

For example, if you use OSC CLI:

1. You need to create an ~/.osc/config.json file to specify the Region of your account, but you leave the access key value and secret key value empty ("").
2. You then specify the --profile, --authentication-method, --login, and --password options when executing OSC CLI commands.

See the code samples in each section of this documentation for specific examples in different programming languages.

If you try to sign requests with an invalid password four times in a row, further authentication attempts will be prevented for 1 minute. This lockout time increases 1 minute every four failed attempts, for up to 10 minutes.

No Authentication

A few API actions do not require any authentication. They are indicated as such in this documentation.

Other Security Mechanisms

In parallel with the authentication schemes, you can add other security mechanisms to your OUTSCALE account, for example to restrict API requests by IP or other criteria.
For more information, see Managing Your API Accesses.

Pagination Tutorial

You can learn more about the pagination methods for read calls in the dedicated pagination tutorial.

Error Codes Reference

You can learn more about errors returned by the API in the dedicated errors page.

AccessKey

CreateAccessKey

POST /CreateAccessKey

Creates an access key for either your root account or an EIM user. The new key is automatically set to ACTIVE.

For more information, see About Access Keys.

Request Parameters

Examples

# Example with access key/secret key authentication

osc-cli api CreateAccessKey --profile "default" \
  --ExpirationDate "2063-04-05"

# Example with login/password authentication

osc-cli api CreateAccessKey --profile "default" --authentication-method "password" --login "$OSC_EMAIL" --password "$OSC_PASSWORD" \
  --ExpirationDate "2063-04-05"

# Example with access key/secret key authentication

oapi-cli --profile "default" CreateAccessKey \
  --ExpirationDate "2063-04-05"

# Example with login/password authentication

oapi-cli --profile "default" --login "$OSC_EMAIL" --password "$OSC_PASSWORD" CreateAccessKey \
  --ExpirationDate "2063-04-05"

# You need Curl version 7.75 or later to use the --aws-sigv4 option

# Example with access key/secret key authentication

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/CreateAccessKey \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "ExpirationDate": "2063-04-05"
  }'

# Example with login/password authentication

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/CreateAccessKey \
  --header "Authorization: Basic $(echo -n "$OSC_EMAIL:$OSC_PASSWORD" | base64)" \
  --header "X-Osc-Date: $(TZ=GMT date +%Y%m%dT%H%M%SZ)" \
  --header 'Content-Type: application/json' \
  --data '{
    "ExpirationDate": "2063-04-05"
  }'

from osc_sdk_python import Gateway
# import os

gw = Gateway(**{"profile": "default"})  # For access key/secret key authentication
# gw = Gateway(email=os.environ.get("OSC_EMAIL"), password=os.environ.get("OSC_PASSWORD"))  # For login/password authentication

result = gw.CreateAccessKey(
    ExpirationDate="2063-04-05",
)
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
        /* For login/password authentication, replace the above awsV4SignParameters key with: */
        /* username: process.env.OSC_USERNAME, */
        /* password: process.env.OSC_PASSWORD, */
    });
    const api = new osc.AccessKeyApi(config);

    const result = await api.createAccessKey({
        createAccessKeyRequest: {
            expirationDate: "2063-04-05",
        },
    });
    console.log(result);

}

main();

See the outscale_access_key resource in the Terraform OUTSCALE provider.

Body (CreateAccessKeyRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  },
  "AccessKey": {
    "State": "ACTIVE",
    "AccessKeyId": "ABCDEFGHIJ0123456789",
    "CreationDate": "2010-10-01T12:34:56.789+0000",
    "ExpirationDate": "2063-04-05T00:00:00.000+0000",
    "SecretKey": "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
    "LastModificationDate": "2010-10-01T12:34:56.789+0000"
  }
}

Response 200 (CreateAccessKeyResponse):

DeleteAccessKey

POST /DeleteAccessKey

Deletes the specified access key of either your root account or an EIM user.

The access key of an EIM user must be in the INACTIVE state to be deleted.

Request Parameters

Examples

# Deleting one of your own access keys (if you are the root account or an EIM user)

osc-cli api DeleteAccessKey --profile "default" \
  --AccessKeyId "ABCDEFGHIJ0123456789"

# Deleting the access key of a specific EIM user

osc-cli api DeleteAccessKey --profile "default" \
  --AccessKeyId "ABCDEFGHIJ0123456789" \
  --UserName "example-user"

# Example with login/password authentication

osc-cli api DeleteAccessKey --profile "default" --authentication-method "password" --login "$OSC_EMAIL" --password "$OSC_PASSWORD" \
  --AccessKeyId "ABCDEFGHIJ0123456789" \
  --UserName "example-user"

# Deleting one of your own access keys (if you are the root account or an EIM user)

oapi-cli --profile "default" DeleteAccessKey \
  --AccessKeyId "ABCDEFGHIJ0123456789"

# Deleting the access key of a specific EIM user

oapi-cli --profile "default" DeleteAccessKey \
  --AccessKeyId "ABCDEFGHIJ0123456789" \
  --UserName "example-user"

# Example with login/password authentication

oapi-cli --profile "default" --login "$OSC_EMAIL" --password "$OSC_PASSWORD" DeleteAccessKey \
  --AccessKeyId "ABCDEFGHIJ0123456789" \
  --UserName "example-user"

# You need Curl version 7.75 or later to use the --aws-sigv4 option

# Deleting one of your own access keys (if you are the root account or an EIM user)

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/DeleteAccessKey \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "AccessKeyId": "ABCDEFGHIJ0123456789"
  }'

# Deleting the access key of a specific EIM user

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/DeleteAccessKey \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "AccessKeyId": "ABCDEFGHIJ0123456789",
    "UserName": "example-user"
  }'

# Example with login/password authentication

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/DeleteAccessKey \
  --header "Authorization: Basic $(echo -n "$OSC_EMAIL:$OSC_PASSWORD" | base64)" \
  --header "X-Osc-Date: $(TZ=GMT date +%Y%m%dT%H%M%SZ)" \
  --header 'Content-Type: application/json' \
  --data '{
    "AccessKeyId": "ABCDEFGHIJ0123456789",
    "UserName": "example-user"
  }'

from osc_sdk_python import Gateway
# import os

gw = Gateway(**{"profile": "default"})  # For access key/secret key authentication
# gw = Gateway(email=os.environ.get("OSC_EMAIL"), password=os.environ.get("OSC_PASSWORD"))  # For login/password authentication

# Deleting one of your own access keys (if you are the root account or an EIM user)
result = gw.DeleteAccessKey(
    AccessKeyId="ABCDEFGHIJ0123456789",
)
print(result)

# Deleting the access key of a specific EIM user
result = gw.DeleteAccessKey(
    AccessKeyId="ABCDEFGHIJ0123456789",
    UserName="example-user",
)
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
        /* For login/password authentication, replace the above awsV4SignParameters key with: */
        /* username: process.env.OSC_USERNAME, */
        /* password: process.env.OSC_PASSWORD, */
    });
    const api = new osc.AccessKeyApi(config);

    /* Deleting one of your own access keys (if you are the root account or an EIM user) */
    const result = await api.deleteAccessKey({
        deleteAccessKeyRequest: {
            accessKeyId: "ABCDEFGHIJ0123456789",
        },
    });
    console.log(result);

    /* Deleting the access key of a specific EIM user */
    const result2 = await api.deleteAccessKey({
        deleteAccessKeyRequest: {
            accessKeyId: "ABCDEFGHIJ0123456789",
            userName: "example-user",
        },
    });
    console.log(result2);

}

main();

See the outscale_access_key resource in the Terraform OUTSCALE provider.

Body (DeleteAccessKeyRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  }
}

Response 200 (DeleteAccessKeyResponse):

ReadAccessKeys

POST /ReadAccessKeys

Lists the access key IDs of either your root account or an EIM user.

Request Parameters

Examples

# Example with access key/secret key authentication

osc-cli api ReadAccessKeys --profile "default" \
  --Filters '{
      "States": ["ACTIVE"]
    }'

# Example with login/password authentication

osc-cli api ReadAccessKeys --profile "default" --authentication-method "password" --login "$OSC_EMAIL" --password "$OSC_PASSWORD" \
  --Filters '{
      "States": ["ACTIVE"]
    }'

# Example with access key/secret key authentication

oapi-cli --profile "default" ReadAccessKeys \
  --Filters '{
      "States": ["ACTIVE"]
    }'

# Example with login/password authentication

oapi-cli --profile "default" --login "$OSC_EMAIL" --password "$OSC_PASSWORD" ReadAccessKeys \
  --Filters '{
      "States": ["ACTIVE"]
    }'

# You need Curl version 7.75 or later to use the --aws-sigv4 option

# Example with access key/secret key authentication

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/ReadAccessKeys \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "Filters": {
      "States": ["ACTIVE"]
    }
  }'

# Example with login/password authentication

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/ReadAccessKeys \
  --header "Authorization: Basic $(echo -n "$OSC_EMAIL:$OSC_PASSWORD" | base64)" \
  --header "X-Osc-Date: $(TZ=GMT date +%Y%m%dT%H%M%SZ)" \
  --header 'Content-Type: application/json' \
  --data '{
    "Filters": {
      "States": ["ACTIVE"]
    }
  }'

from osc_sdk_python import Gateway
# import os

gw = Gateway(**{"profile": "default"})  # For access key/secret key authentication
# gw = Gateway(email=os.environ.get("OSC_EMAIL"), password=os.environ.get("OSC_PASSWORD"))  # For login/password authentication

result = gw.ReadAccessKeys(
    Filters={
        "States": ["ACTIVE"],
    },
)
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
        /* For login/password authentication, replace the above awsV4SignParameters key with: */
        /* username: process.env.OSC_USERNAME, */
        /* password: process.env.OSC_PASSWORD, */
    });
    const api = new osc.AccessKeyApi(config);

    const result = await api.readAccessKeys({
        readAccessKeysRequest: {
            filters: {
                states: ["ACTIVE"],
            },
        },
    });
    console.log(result);

}

main();

See the outscale_access_key or outscale_access_keys data sources in the Terraform OUTSCALE provider.

Body (ReadAccessKeysRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  },
  "AccessKeys": [
    {
      "State": "ACTIVE",
      "AccessKeyId": "ABCDEFGHIJ0123456789",
      "CreationDate": "2010-10-01T12:34:56.789+0000",
      "ExpirationDate": "2063-04-05T00:00:00.000+0000",
      "LastModificationDate": "2010-10-01T12:34:56.789+0000"
    }
  ]
}

Response 200 (ReadAccessKeysResponse):

UpdateAccessKey

POST /UpdateAccessKey

Modifies the attributes of the specified access key of either your root account or an EIM user.

Request Parameters

Examples

# Updating the expiration date of the access key

osc-cli api UpdateAccessKey --profile "default" \
  --AccessKeyId "ABCDEFGHIJ0123456789" \
  --State "ACTIVE" \
  --ExpirationDate "2063-04-05"

# Updating one of your own access keys (if you are the root account or an EIM user)

osc-cli api UpdateAccessKey --profile "default" \
  --AccessKeyId "ABCDEFGHIJ0123456789" \
  --State "ACTIVE"

# Updating the access key of a specific EIM user

osc-cli api UpdateAccessKey --profile "default" \
  --AccessKeyId "ABCDEFGHIJ0123456789" \
  --State "ACTIVE" \
  --UserName "example-user"

# Example with login/password authentication

osc-cli api UpdateAccessKey --profile "default" --authentication-method "password" --login "$OSC_EMAIL" --password "$OSC_PASSWORD" \
  --AccessKeyId "ABCDEFGHIJ0123456789" \
  --State "ACTIVE" \
  --UserName "example-user"

# Updating the expiration date of the access key

oapi-cli --profile "default" UpdateAccessKey \
  --AccessKeyId "ABCDEFGHIJ0123456789" \
  --State "ACTIVE" \
  --ExpirationDate "2063-04-05"

# Updating one of your own access keys (if you are the root account or an EIM user)

oapi-cli --profile "default" UpdateAccessKey \
  --AccessKeyId "ABCDEFGHIJ0123456789" \
  --State "ACTIVE"

# Updating the access key of a specific EIM user

oapi-cli --profile "default" UpdateAccessKey \
  --AccessKeyId "ABCDEFGHIJ0123456789" \
  --State "ACTIVE" \
  --UserName "example-user"

# Example with login/password authentication

oapi-cli --profile "default" --login "$OSC_EMAIL" --password "$OSC_PASSWORD" UpdateAccessKey \
  --AccessKeyId "ABCDEFGHIJ0123456789" \
  --State "ACTIVE" \
  --UserName "example-user"

# You need Curl version 7.75 or later to use the --aws-sigv4 option

# Updating the expiration date of the access key

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/UpdateAccessKey \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "AccessKeyId": "ABCDEFGHIJ0123456789",
    "State": "ACTIVE",
    "ExpirationDate": "2063-04-05"
  }'

# Updating one of your own access keys (if you are the root account or an EIM user)

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/UpdateAccessKey \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "AccessKeyId": "ABCDEFGHIJ0123456789",
    "State": "ACTIVE"
  }'

# Updating the access key of a specific EIM user

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/UpdateAccessKey \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "AccessKeyId": "ABCDEFGHIJ0123456789",
    "State": "ACTIVE",
    "UserName": "example-user"
  }'

# Example with login/password authentication

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/UpdateAccessKey \
  --header "Authorization: Basic $(echo -n "$OSC_EMAIL:$OSC_PASSWORD" | base64)" \
  --header "X-Osc-Date: $(TZ=GMT date +%Y%m%dT%H%M%SZ)" \
  --header 'Content-Type: application/json' \
  --data '{
    "AccessKeyId": "ABCDEFGHIJ0123456789",
    "State": "ACTIVE",
    "UserName": "example-user"
  }'

from osc_sdk_python import Gateway
# import os

gw = Gateway(**{"profile": "default"})  # For access key/secret key authentication
# gw = Gateway(email=os.environ.get("OSC_EMAIL"), password=os.environ.get("OSC_PASSWORD"))  # For login/password authentication

# Updating the expiration date of the access key
result = gw.UpdateAccessKey(
    AccessKeyId="ABCDEFGHIJ0123456789",
    State="ACTIVE",
    ExpirationDate="2063-04-05",
)
print(result)

# Updating one of your own access keys (if you are the root account or an EIM user)
result = gw.UpdateAccessKey(
    AccessKeyId="ABCDEFGHIJ0123456789",
    State="ACTIVE",
)
print(result)

# Updating the access key of a specific EIM user
result = gw.UpdateAccessKey(
    AccessKeyId="ABCDEFGHIJ0123456789",
    State="ACTIVE",
    UserName="example-user",
)
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
        /* For login/password authentication, replace the above awsV4SignParameters key with: */
        /* username: process.env.OSC_USERNAME, */
        /* password: process.env.OSC_PASSWORD, */
    });
    const api = new osc.AccessKeyApi(config);

    /* Updating the expiration date of the access key */
    const result = await api.updateAccessKey({
        updateAccessKeyRequest: {
            accessKeyId: "ABCDEFGHIJ0123456789",
            state: "ACTIVE",
            expirationDate: "2063-04-05",
        },
    });
    console.log(result);

    /* Updating one of your own access keys (if you are the root account or an EIM user) */
    const result2 = await api.updateAccessKey({
        updateAccessKeyRequest: {
            accessKeyId: "ABCDEFGHIJ0123456789",
            state: "ACTIVE",
        },
    });
    console.log(result2);

    /* Updating the access key of a specific EIM user */
    const result3 = await api.updateAccessKey({
        updateAccessKeyRequest: {
            accessKeyId: "ABCDEFGHIJ0123456789",
            state: "ACTIVE",
            userName: "example-user",
        },
    });
    console.log(result3);

}

main();

See the outscale_access_key resource in the Terraform OUTSCALE provider.

Body (UpdateAccessKeyRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  },
  "AccessKey": {
    "State": "ACTIVE",
    "AccessKeyId": "ABCDEFGHIJ0123456789",
    "CreationDate": "2010-10-01T12:34:56.789+0000",
    "ExpirationDate": "2063-04-05T00:00:00.000+0000",
    "LastModificationDate": "2017-05-10T12:34:56.789+0000"
  }
}

Response 200 (UpdateAccessKeyResponse):

Account

CheckAuthentication

POST /CheckAuthentication

Validates the authenticity of the account.

Request Parameters

Examples

osc-cli api CheckAuthentication --profile "default" \
  --Login "example@example.com" \
  --Password "$OSC_PASSWORD"

oapi-cli --profile "default" CheckAuthentication \
  --Login "example@example.com" \
  --Password "$OSC_PASSWORD"

# You need Curl version 7.75 or later to use the --aws-sigv4 option

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/CheckAuthentication \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "Login": "example@example.com",
    "Password": "'$OSC_PASSWORD'"
  }'

from osc_sdk_python import Gateway
import os

gw = Gateway(**{"profile": "default"})

result = gw.CheckAuthentication(
    Login="example@example.com",
    Password=os.environ.get("OSC_PASSWORD"),
)
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
    });
    const api = new osc.AccountApi(config);

    const result = await api.checkAuthentication({
        checkAuthenticationRequest: {
            login: "example@example.com",
            password: process.env.OSC_PASSWORD,
        },
    });
    console.log(result);

}

main();

There is no equivalent for this method in the Terraform OUTSCALE provider.

Body (CheckAuthenticationRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  }
}

Response 200 (CheckAuthenticationResponse):

CreateAccount

POST /CreateAccount

Creates an OUTSCALE account.

[IMPORTANT]

• You need OUTSCALE credentials and the appropriate quotas to create an account via API. To get quotas, you can send an email to sales@outscale.com.
  
• If you want to pass a numeral value as a string instead of an integer, you must wrap your string in additional quotes (for example, '"92000"').

For more information, see About Your Account.

Request Parameters

Examples

osc-cli api CreateAccount --profile "default" \
  --City "SAINT-CLOUD" \
  --CompanyName "EXAMPLE SAS" \
  --Country "FRANCE" \
  --CustomerId '"87654321"' \
  --Email "example@example.com" \
  --FirstName "JEAN" \
  --LastName "DUPONT" \
  --ZipCode '"92210"'

oapi-cli --profile "default" CreateAccount \
  --City "SAINT-CLOUD" \
  --CompanyName "EXAMPLE SAS" \
  --Country "FRANCE" \
  --CustomerId "87654321" \
  --Email "example@example.com" \
  --FirstName "JEAN" \
  --LastName "DUPONT" \
  --ZipCode "92210"

# You need Curl version 7.75 or later to use the --aws-sigv4 option

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/CreateAccount \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "City": "SAINT-CLOUD",
    "CompanyName": "EXAMPLE SAS",
    "Country": "FRANCE",
    "CustomerId": "87654321",
    "Email": "example@example.com",
    "FirstName": "JEAN",
    "LastName": "DUPONT",
    "ZipCode": "92210"
  }'

from osc_sdk_python import Gateway

gw = Gateway(**{"profile": "default"})

result = gw.CreateAccount(
    City="SAINT-CLOUD",
    CompanyName="EXAMPLE SAS",
    Country="FRANCE",
    CustomerId="87654321",
    Email="example@example.com",
    FirstName="JEAN",
    LastName="DUPONT",
    ZipCode="92210",
)
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
    });
    const api = new osc.AccountApi(config);

    const result = await api.createAccount({
        createAccountRequest: {
            city: "SAINT-CLOUD",
            companyName: "EXAMPLE SAS",
            country: "FRANCE",
            customerId: "87654321",
            email: "example@example.com",
            firstName: "JEAN",
            lastName: "DUPONT",
            zipCode: "92210",
        },
    });
    console.log(result);

}

main();

There is no equivalent for this method in the Terraform OUTSCALE provider.

Body (CreateAccountRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  },
  "Account": {
    "ZipCode": "92210",
    "CompanyName": "EXAMPLE SAS",
    "FirstName": "JEAN",
    "City": "SAINT-CLOUD",
    "Country": "FRANCE",
    "LastName": "DUPONT",
    "AccountId": "123456789012",
    "Email": "example@example.com"
  }
}

Response 200 (CreateAccountResponse):

ReadAccounts

POST /ReadAccounts

Gets information about the account that sent the request.

Request Parameters

Examples

osc-cli api ReadAccounts --profile "default"

oapi-cli --profile "default" ReadAccounts

# You need Curl version 7.75 or later to use the --aws-sigv4 option

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/ReadAccounts \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{}'

from osc_sdk_python import Gateway

gw = Gateway(**{"profile": "default"})

result = gw.ReadAccounts()
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
    });
    const api = new osc.AccountApi(config);

    const result = await api.readAccounts({
        readAccountsRequest: {},
    });
    console.log(result);

}

main();

See the outscale_account or outscale_accounts data sources in the Terraform OUTSCALE provider.

Body (ReadAccountsRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  },
  "Accounts": [
    {
      "ZipCode": "92210",
      "CompanyName": "EXAMPLE SAS",
      "FirstName": "JEAN",
      "City": "SAINT-CLOUD",
      "Country": "FRANCE",
      "LastName": "DUPONT",
      "AccountId": "123456789012",
      "CustomerId": "87654321",
      "Email": "example@example.com"
    }
  ]
}

Response 200 (ReadAccountsResponse):

ReadConsumptionAccount

POST /ReadConsumptionAccount

Gets information about the consumption of your account for each billable resource within the specified time period.

Request Parameters

Examples

osc-cli api ReadConsumptionAccount --profile "default" \
  --FromDate "2023-06-01" \
  --ToDate "2023-07-01" \
  --ShowPrice True

oapi-cli --profile "default" ReadConsumptionAccount \
  --FromDate "2023-06-01" \
  --ToDate "2023-07-01" \
  --ShowPrice True

# You need Curl version 7.75 or later to use the --aws-sigv4 option

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/ReadConsumptionAccount \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "FromDate": "2023-06-01",
    "ToDate": "2023-07-01",
    "ShowPrice": true
  }'

from osc_sdk_python import Gateway

gw = Gateway(**{"profile": "default"})

result = gw.ReadConsumptionAccount(
    FromDate="2023-06-01",
    ToDate="2023-07-01",
    ShowPrice=True,
)
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
    });
    const api = new osc.AccountApi(config);

    const result = await api.readConsumptionAccount({
        readConsumptionAccountRequest: {
            fromDate: "2023-06-01",
            toDate: "2023-07-01",
            showPrice: true,
        },
    });
    console.log(result);

}

main();

There is no equivalent for this method in the Terraform OUTSCALE provider.

Body (ReadConsumptionAccountRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  },
  "ConsumptionEntries": [
    {
      "UnitPrice": 0.044,
      "Type": "BoxUsage:tinav4.c1r1p2",
      "Operation": "RunInstances-OD",
      "SubregionName": "eu-west-2a",
      "Value": 1392,
      "Title": "Instance - On demand - tinav4.c1r1 high performance - par heure",
      "Category": "compute",
      "ToDate": "2023-06-30T00:00:00.000+0000",
      "Service": "TinaOS-FCU",
      "AccountId": "123456789012",
      "PayingAccountId": "123456789012",
      "FromDate": "2023-06-01T00:00:00.000+0000",
      "Price": 61.248
    }
  ],
  "Currency": "EUR"
}

Response 200 (ReadConsumptionAccountResponse):

UpdateAccount

POST /UpdateAccount

Updates the account information for the account that sends the request.

Request Parameters

Examples

osc-cli api UpdateAccount --profile "default" \
  --AdditionalEmails '["another@example.com", "yet.another@example.com"]'

oapi-cli --profile "default" UpdateAccount \
  --AdditionalEmails '["another@example.com", "yet.another@example.com"]'

# You need Curl version 7.75 or later to use the --aws-sigv4 option

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/UpdateAccount \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "AdditionalEmails": ["another@example.com", "yet.another@example.com"]
  }'

from osc_sdk_python import Gateway

gw = Gateway(**{"profile": "default"})

result = gw.UpdateAccount(
    AdditionalEmails=["another@example.com","yet.another@example.com"],
)
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
    });
    const api = new osc.AccountApi(config);

    const result = await api.updateAccount({
        updateAccountRequest: {
            additionalEmails: ["another@example.com", "yet.another@example.com"],
        },
    });
    console.log(result);

}

main();

There is no equivalent for this method in the Terraform OUTSCALE provider.

Body (UpdateAccountRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  },
  "Account": {
    "ZipCode": "92210",
    "CompanyName": "EXAMPLE SAS",
    "FirstName": "JEAN",
    "AdditionalEmails": [
      "another@example.com",
      "yet.another@example.com"
    ],
    "City": "SAINT-CLOUD",
    "Country": "FRANCE",
    "LastName": "DUPONT",
    "AccountId": "123456789012",
    "CustomerId": "87654321",
    "Email": "example@example.com"
  }
}

Response 200 (UpdateAccountResponse):

ApiAccessPolicy

ReadApiAccessPolicy

POST /ReadApiAccessPolicy

Gets information about the API access policy of your account.

For more information, see About Your API Access Policy.

Request Parameters

Examples

# Example with access key/secret key authentication

osc-cli api ReadApiAccessPolicy --profile "default"

# Example with login/password authentication

osc-cli api ReadApiAccessPolicy --profile "default" --authentication-method "password" --login "$OSC_EMAIL" --password "$OSC_PASSWORD"

# Example with access key/secret key authentication

oapi-cli --profile "default" ReadApiAccessPolicy

# Example with login/password authentication

oapi-cli --profile "default" --login "$OSC_EMAIL" --password "$OSC_PASSWORD" ReadApiAccessPolicy

# You need Curl version 7.75 or later to use the --aws-sigv4 option

# Example with access key/secret key authentication

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/ReadApiAccessPolicy \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{}'

# Example with login/password authentication

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/ReadApiAccessPolicy \
  --header "Authorization: Basic $(echo -n "$OSC_EMAIL:$OSC_PASSWORD" | base64)" \
  --header "X-Osc-Date: $(TZ=GMT date +%Y%m%dT%H%M%SZ)" \
  --header 'Content-Type: application/json' \
  --data '{}'

from osc_sdk_python import Gateway
# import os

gw = Gateway(**{"profile": "default"})  # For access key/secret key authentication
# gw = Gateway(email=os.environ.get("OSC_EMAIL"), password=os.environ.get("OSC_PASSWORD"))  # For login/password authentication

result = gw.ReadApiAccessPolicy()
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
        /* For login/password authentication, replace the above awsV4SignParameters key with: */
        /* username: process.env.OSC_USERNAME, */
        /* password: process.env.OSC_PASSWORD, */
    });
    const api = new osc.ApiAccessPolicyApi(config);

    const result = await api.readApiAccessPolicy({
        readApiAccessPolicyRequest: {},
    });
    console.log(result);

}

main();

See the outscale_api_access_policy data source in the Terraform OUTSCALE provider.

Body (ReadApiAccessPolicyRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  },
  "ApiAccessPolicy": {
    "RequireTrustedEnv": false,
    "MaxAccessKeyExpirationSeconds": 0
  }
}

Response 200 (ReadApiAccessPolicyResponse):

Other responses:

• Response 400 (ErrorResponse): The HTTP 400 response (Bad Request).
• Response 401 (ErrorResponse): The HTTP 401 response (Unauthorized).
• Response 500 (ErrorResponse): The HTTP 500 response (Internal Server Error).

UpdateApiAccessPolicy

POST /UpdateApiAccessPolicy

Updates the API access policy of your account.

[IMPORTANT]
Only one API access policy can be associated with your account.

Request Parameters

Examples

# Require expiration dates of maximum 1 year

osc-cli api UpdateApiAccessPolicy --profile "default" \
  --MaxAccessKeyExpirationSeconds 31536000 \
  --RequireTrustedEnv False

# Require expiration dates of maximum 100 years and activate a trusted session

osc-cli api UpdateApiAccessPolicy --profile "default" \
  --MaxAccessKeyExpirationSeconds 3153600000 \
  --RequireTrustedEnv True

# Do not require expiration dates and deactivate a trusted session

osc-cli api UpdateApiAccessPolicy --profile "default" \
  --MaxAccessKeyExpirationSeconds 0 \
  --RequireTrustedEnv False

# Example with login/password authentication

osc-cli api UpdateApiAccessPolicy --profile "default" --authentication-method "password" --login "$OSC_EMAIL" --password "$OSC_PASSWORD" \
  --MaxAccessKeyExpirationSeconds 0 \
  --RequireTrustedEnv False

# Require expiration dates of maximum 1 year

oapi-cli --profile "default" UpdateApiAccessPolicy \
  --MaxAccessKeyExpirationSeconds 31536000 \
  --RequireTrustedEnv False

# Require expiration dates of maximum 100 years and activate a trusted session

oapi-cli --profile "default" UpdateApiAccessPolicy \
  --MaxAccessKeyExpirationSeconds 3153600000 \
  --RequireTrustedEnv True

# Do not require expiration dates and deactivate a trusted session

oapi-cli --profile "default" UpdateApiAccessPolicy \
  --MaxAccessKeyExpirationSeconds 0 \
  --RequireTrustedEnv False

# Example with login/password authentication

oapi-cli --profile "default" --login "$OSC_EMAIL" --password "$OSC_PASSWORD" UpdateApiAccessPolicy \
  --MaxAccessKeyExpirationSeconds 0 \
  --RequireTrustedEnv False

# You need Curl version 7.75 or later to use the --aws-sigv4 option

# Require expiration dates of maximum 1 year

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/UpdateApiAccessPolicy \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "MaxAccessKeyExpirationSeconds": 31536000,
    "RequireTrustedEnv": false
  }'

# Require expiration dates of maximum 100 years and activate a trusted session

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/UpdateApiAccessPolicy \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "MaxAccessKeyExpirationSeconds": 3153600000,
    "RequireTrustedEnv": true
  }'

# Do not require expiration dates and deactivate a trusted session

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/UpdateApiAccessPolicy \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "MaxAccessKeyExpirationSeconds": 0,
    "RequireTrustedEnv": false
  }'

# Example with login/password authentication

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/UpdateApiAccessPolicy \
  --header "Authorization: Basic $(echo -n "$OSC_EMAIL:$OSC_PASSWORD" | base64)" \
  --header "X-Osc-Date: $(TZ=GMT date +%Y%m%dT%H%M%SZ)" \
  --header 'Content-Type: application/json' \
  --data '{
    "MaxAccessKeyExpirationSeconds": 0,
    "RequireTrustedEnv": false
  }'

from osc_sdk_python import Gateway
# import os

gw = Gateway(**{"profile": "default"})  # For access key/secret key authentication
# gw = Gateway(email=os.environ.get("OSC_EMAIL"), password=os.environ.get("OSC_PASSWORD"))  # For login/password authentication

# Require expiration dates of maximum 1 year
result = gw.UpdateApiAccessPolicy(
    MaxAccessKeyExpirationSeconds=31536000,
    RequireTrustedEnv=False,
)
print(result)

# Require expiration dates of maximum 100 years and activate a trusted session
result = gw.UpdateApiAccessPolicy(
    MaxAccessKeyExpirationSeconds=3153600000,
    RequireTrustedEnv=True,
)
print(result)

# Do not require expiration dates and deactivate a trusted session
result = gw.UpdateApiAccessPolicy(
    MaxAccessKeyExpirationSeconds=0,
    RequireTrustedEnv=False,
)
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
        /* For login/password authentication, replace the above awsV4SignParameters key with: */
        /* username: process.env.OSC_USERNAME, */
        /* password: process.env.OSC_PASSWORD, */
    });
    const api = new osc.ApiAccessPolicyApi(config);

    /* Require expiration dates of maximum 1 year */
    const result = await api.updateApiAccessPolicy({
        updateApiAccessPolicyRequest: {
            maxAccessKeyExpirationSeconds: 31536000,
            requireTrustedEnv: false,
        },
    });
    console.log(result);

    /* Require expiration dates of maximum 100 years and activate a trusted session */
    const result2 = await api.updateApiAccessPolicy({
        updateApiAccessPolicyRequest: {
            maxAccessKeyExpirationSeconds: 3153600000,
            requireTrustedEnv: true,
        },
    });
    console.log(result2);

    /* Do not require expiration dates and deactivate a trusted session */
    const result3 = await api.updateApiAccessPolicy({
        updateApiAccessPolicyRequest: {
            maxAccessKeyExpirationSeconds: 0,
            requireTrustedEnv: false,
        },
    });
    console.log(result3);

}

main();

See the outscale_api_access_policy resource in the Terraform OUTSCALE provider.

Body (UpdateApiAccessPolicyRequest):

Response Elements

Examples

# Require expiration dates of maximum 1 year

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  },
  "ApiAccessPolicy": {
    "RequireTrustedEnv": false,
    "MaxAccessKeyExpirationSeconds": 31536000
  }
}

# Require expiration dates of maximum 100 years and activate a trusted session

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  },
  "ApiAccessPolicy": {
    "RequireTrustedEnv": true,
    "MaxAccessKeyExpirationSeconds": 3153600000
  }
}

# Do not require expiration dates and deactivate a trusted session

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  },
  "ApiAccessPolicy": {
    "RequireTrustedEnv": false,
    "MaxAccessKeyExpirationSeconds": 0
  }
}

Response 200 (UpdateApiAccessPolicyResponse):

Other responses:

• Response 400 (ErrorResponse): The HTTP 400 response (Bad Request).
• Response 401 (ErrorResponse): The HTTP 401 response (Unauthorized).
• Response 500 (ErrorResponse): The HTTP 500 response (Internal Server Error).

ApiAccessRule

CreateApiAccessRule

POST /CreateApiAccessRule

Creates a rule to allow access to the API from your account.
You need to specify at least the CaIds or the IpRanges parameter.

[NOTE]
By default, your account has a set of rules allowing global access, that you can delete.

For more information, see About API Access Rules.

Request Parameters

Examples

# Creating an API access rule based on IPs

osc-cli api CreateApiAccessRule --profile "default" \
  --IpRanges '["192.0.2.0", "198.51.100.0/24"]' \
  --Description "Basic API Access Rule with IPs"

# Creating an API access rule based on IPs and Certificate Authority (CA)

osc-cli api CreateApiAccessRule --profile "default" \
  --IpRanges '["192.0.2.0", "198.51.100.0/24"]' \
  --CaIds '["ca-fedcba0987654321fedcba0987654321"]' \
  --Description "API Access Rule with IPs and CA"

# Example with login/password authentication

osc-cli api CreateApiAccessRule --profile "default" --authentication-method "password" --login "$OSC_EMAIL" --password "$OSC_PASSWORD" \
  --IpRanges '["192.0.2.0", "198.51.100.0/24"]' \
  --CaIds '["ca-fedcba0987654321fedcba0987654321"]' \
  --Description "API Access Rule with IPs and CA"

# Creating an API access rule based on IPs

oapi-cli --profile "default" CreateApiAccessRule \
  --IpRanges '["192.0.2.0", "198.51.100.0/24"]' \
  --Description "Basic API Access Rule with IPs"

# Creating an API access rule based on IPs and Certificate Authority (CA)

oapi-cli --profile "default" CreateApiAccessRule \
  --IpRanges '["192.0.2.0", "198.51.100.0/24"]' \
  --CaIds '["ca-fedcba0987654321fedcba0987654321"]' \
  --Description "API Access Rule with IPs and CA"

# Example with login/password authentication

oapi-cli --profile "default" --login "$OSC_EMAIL" --password "$OSC_PASSWORD" CreateApiAccessRule \
  --IpRanges '["192.0.2.0", "198.51.100.0/24"]' \
  --CaIds '["ca-fedcba0987654321fedcba0987654321"]' \
  --Description "API Access Rule with IPs and CA"

# You need Curl version 7.75 or later to use the --aws-sigv4 option

# Creating an API access rule based on IPs

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/CreateApiAccessRule \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "IpRanges": ["192.0.2.0", "198.51.100.0/24"],
    "Description": "Basic API Access Rule with IPs"
  }'

# Creating an API access rule based on IPs and Certificate Authority (CA)

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/CreateApiAccessRule \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "IpRanges": ["192.0.2.0", "198.51.100.0/24"],
    "CaIds": ["ca-fedcba0987654321fedcba0987654321"],
    "Description": "API Access Rule with IPs and CA"
  }'

# Example with login/password authentication

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/CreateApiAccessRule \
  --header "Authorization: Basic $(echo -n "$OSC_EMAIL:$OSC_PASSWORD" | base64)" \
  --header "X-Osc-Date: $(TZ=GMT date +%Y%m%dT%H%M%SZ)" \
  --header 'Content-Type: application/json' \
  --data '{
    "IpRanges": ["192.0.2.0", "198.51.100.0/24"],
    "CaIds": ["ca-fedcba0987654321fedcba0987654321"],
    "Description": "API Access Rule with IPs and CA"
  }'

from osc_sdk_python import Gateway
# import os

gw = Gateway(**{"profile": "default"})  # For access key/secret key authentication
# gw = Gateway(email=os.environ.get("OSC_EMAIL"), password=os.environ.get("OSC_PASSWORD"))  # For login/password authentication

# Creating an API access rule based on IPs
result = gw.CreateApiAccessRule(
    IpRanges=["192.0.2.0","198.51.100.0/24"],
    Description="Basic API Access Rule with IPs",
)
print(result)

# Creating an API access rule based on IPs and Certificate Authority (CA)
result = gw.CreateApiAccessRule(
    IpRanges=["192.0.2.0","198.51.100.0/24"],
    CaIds=["ca-fedcba0987654321fedcba0987654321"],
    Description="API Access Rule with IPs and CA",
)
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
        /* For login/password authentication, replace the above awsV4SignParameters key with: */
        /* username: process.env.OSC_USERNAME, */
        /* password: process.env.OSC_PASSWORD, */
    });
    const api = new osc.ApiAccessRuleApi(config);

    /* Creating an API access rule based on IPs */
    const result = await api.createApiAccessRule({
        createApiAccessRuleRequest: {
            ipRanges: ["192.0.2.0", "198.51.100.0/24"],
            description: "Basic API Access Rule with IPs",
        },
    });
    console.log(result);

    /* Creating an API access rule based on IPs and Certificate Authority (CA) */
    const result2 = await api.createApiAccessRule({
        createApiAccessRuleRequest: {
            ipRanges: ["192.0.2.0", "198.51.100.0/24"],
            caIds: ["ca-fedcba0987654321fedcba0987654321"],
            description: "API Access Rule with IPs and CA",
        },
    });
    console.log(result2);

}

main();

See the outscale_api_access_rule resource in the Terraform OUTSCALE provider.

Body (CreateApiAccessRuleRequest):

Response Elements

Examples

# Creating an API access rule based on IPs

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  },
  "ApiAccessRule": {
    "IpRanges": [
      "192.0.2.0",
      "198.51.100.0/24"
    ],
    "ApiAccessRuleId": "aar-fedcba0987654321fedcba0987654321",
    "CaIds": [],
    "Cns": [],
    "Description": "Basic API Access Rule with IPs"
  }
}

# Creating an API access rule based on IPs and Certificate Authority (CA)

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  },
  "ApiAccessRule": {
    "IpRanges": [
      "192.0.2.0",
      "198.51.100.0/24"
    ],
    "ApiAccessRuleId": "aar-fedcba0987654321fedcba0987654321",
    "CaIds": [
      "ca-fedcba0987654321fedcba0987654321"
    ],
    "Cns": [],
    "Description": "API Access Rule with IPs and CA"
  }
}

Response 200 (CreateApiAccessRuleResponse):

DeleteApiAccessRule

POST /DeleteApiAccessRule

Deletes a specified API access rule.

[IMPORTANT]
You cannot delete the last remaining API access rule. However, if you delete all the API access rules that allow you to access the APIs, you need to contact the Support team to regain access. For more information, see Technical Support.

Request Parameters

Examples

# Example with access key/secret key authentication

osc-cli api DeleteApiAccessRule --profile "default" \
  --ApiAccessRuleId "aar-1234567890abcdef1234567890abcdef"

# Example with login/password authentication

osc-cli api DeleteApiAccessRule --profile "default" --authentication-method "password" --login "$OSC_EMAIL" --password "$OSC_PASSWORD" \
  --ApiAccessRuleId "aar-1234567890abcdef1234567890abcdef"

# Example with access key/secret key authentication

oapi-cli --profile "default" DeleteApiAccessRule \
  --ApiAccessRuleId "aar-1234567890abcdef1234567890abcdef"

# Example with login/password authentication

oapi-cli --profile "default" --login "$OSC_EMAIL" --password "$OSC_PASSWORD" DeleteApiAccessRule \
  --ApiAccessRuleId "aar-1234567890abcdef1234567890abcdef"

# You need Curl version 7.75 or later to use the --aws-sigv4 option

# Example with access key/secret key authentication

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/DeleteApiAccessRule \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "ApiAccessRuleId": "aar-1234567890abcdef1234567890abcdef"
  }'

# Example with login/password authentication

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/DeleteApiAccessRule \
  --header "Authorization: Basic $(echo -n "$OSC_EMAIL:$OSC_PASSWORD" | base64)" \
  --header "X-Osc-Date: $(TZ=GMT date +%Y%m%dT%H%M%SZ)" \
  --header 'Content-Type: application/json' \
  --data '{
    "ApiAccessRuleId": "aar-1234567890abcdef1234567890abcdef"
  }'

from osc_sdk_python import Gateway
# import os

gw = Gateway(**{"profile": "default"})  # For access key/secret key authentication
# gw = Gateway(email=os.environ.get("OSC_EMAIL"), password=os.environ.get("OSC_PASSWORD"))  # For login/password authentication

result = gw.DeleteApiAccessRule(
    ApiAccessRuleId="aar-1234567890abcdef1234567890abcdef",
)
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
        /* For login/password authentication, replace the above awsV4SignParameters key with: */
        /* username: process.env.OSC_USERNAME, */
        /* password: process.env.OSC_PASSWORD, */
    });
    const api = new osc.ApiAccessRuleApi(config);

    const result = await api.deleteApiAccessRule({
        deleteApiAccessRuleRequest: {
            apiAccessRuleId: "aar-1234567890abcdef1234567890abcdef",
        },
    });
    console.log(result);

}

main();

See the outscale_api_access_rule resource in the Terraform OUTSCALE provider.

Body (DeleteApiAccessRuleRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  }
}

Response 200 (DeleteApiAccessRuleResponse):

ReadApiAccessRules

POST /ReadApiAccessRules

Lists one or more API access rules.

Request Parameters

Examples

# Example with access key/secret key authentication

osc-cli api ReadApiAccessRules --profile "default" \
  --Filters '{
      "ApiAccessRuleIds": ["aar-1234567890abcdef1234567890abcdef"]
    }'

# Example with login/password authentication

osc-cli api ReadApiAccessRules --profile "default" --authentication-method "password" --login "$OSC_EMAIL" --password "$OSC_PASSWORD" \
  --Filters '{
      "ApiAccessRuleIds": ["aar-1234567890abcdef1234567890abcdef"]
    }'

# Example with access key/secret key authentication

oapi-cli --profile "default" ReadApiAccessRules \
  --Filters '{
      "ApiAccessRuleIds": ["aar-1234567890abcdef1234567890abcdef"]
    }'

# Example with login/password authentication

oapi-cli --profile "default" --login "$OSC_EMAIL" --password "$OSC_PASSWORD" ReadApiAccessRules \
  --Filters '{
      "ApiAccessRuleIds": ["aar-1234567890abcdef1234567890abcdef"]
    }'

# You need Curl version 7.75 or later to use the --aws-sigv4 option

# Example with access key/secret key authentication

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/ReadApiAccessRules \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "Filters": {
      "ApiAccessRuleIds": ["aar-1234567890abcdef1234567890abcdef"]
    }
  }'

# Example with login/password authentication

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/ReadApiAccessRules \
  --header "Authorization: Basic $(echo -n "$OSC_EMAIL:$OSC_PASSWORD" | base64)" \
  --header "X-Osc-Date: $(TZ=GMT date +%Y%m%dT%H%M%SZ)" \
  --header 'Content-Type: application/json' \
  --data '{
    "Filters": {
      "ApiAccessRuleIds": ["aar-1234567890abcdef1234567890abcdef"]
    }
  }'

from osc_sdk_python import Gateway
# import os

gw = Gateway(**{"profile": "default"})  # For access key/secret key authentication
# gw = Gateway(email=os.environ.get("OSC_EMAIL"), password=os.environ.get("OSC_PASSWORD"))  # For login/password authentication

result = gw.ReadApiAccessRules(
    Filters={
        "ApiAccessRuleIds": ["aar-1234567890abcdef1234567890abcdef"],
    },
)
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
        /* For login/password authentication, replace the above awsV4SignParameters key with: */
        /* username: process.env.OSC_USERNAME, */
        /* password: process.env.OSC_PASSWORD, */
    });
    const api = new osc.ApiAccessRuleApi(config);

    const result = await api.readApiAccessRules({
        readApiAccessRulesRequest: {
            filters: {
                apiAccessRuleIds: ["aar-1234567890abcdef1234567890abcdef"],
            },
        },
    });
    console.log(result);

}

main();

See the outscale_api_access_rule or outscale_api_access_rules data sources in the Terraform OUTSCALE provider.

Body (ReadApiAccessRulesRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  },
  "ApiAccessRules": [
    {
      "IpRanges": [
        "0.0.0.0/0"
      ],
      "ApiAccessRuleId": "aar-1234567890abcdef1234567890abcdef",
      "CaIds": [],
      "Cns": [],
      "Description": "Allows all IPv4 domain"
    },
    {
      "IpRanges": [
        "46.231.144.178/32"
      ],
      "ApiAccessRuleId": "aar-abcdef1234567890abcdef1234567890",
      "CaIds": [],
      "Cns": [],
      "Description": "Allows Outscale Cockpit of this region"
    }
  ]
}

Response 200 (ReadApiAccessRulesResponse):

UpdateApiAccessRule

POST /UpdateApiAccessRule

Modifies a specified API access rule.

[WARNING]

• The new rule you specify fully replaces the old rule. Therefore, for a parameter that is not specified, any previously set value is deleted.
  
• If, as result of your modification, you no longer have access to the APIs, you will need to contact the Support team to regain access. For more information, see Technical Support.

Request Parameters

Examples

# Example with access key/secret key authentication

osc-cli api UpdateApiAccessRule --profile "default" \
  --ApiAccessRuleId "aar-1234567890abcdef1234567890abcdef" \
  --IpRanges '["0.0.0.0/0"]' \
  --Description "Allows all Ipv4 domain"

# Example with login/password authentication

osc-cli api UpdateApiAccessRule --profile "default" --authentication-method "password" --login "$OSC_EMAIL" --password "$OSC_PASSWORD" \
  --ApiAccessRuleId "aar-1234567890abcdef1234567890abcdef" \
  --IpRanges '["0.0.0.0/0"]' \
  --Description "Allows all Ipv4 domain"

# Example with access key/secret key authentication

oapi-cli --profile "default" UpdateApiAccessRule \
  --ApiAccessRuleId "aar-1234567890abcdef1234567890abcdef" \
  --IpRanges '["0.0.0.0/0"]' \
  --Description "Allows all Ipv4 domain"

# Example with login/password authentication

oapi-cli --profile "default" --login "$OSC_EMAIL" --password "$OSC_PASSWORD" UpdateApiAccessRule \
  --ApiAccessRuleId "aar-1234567890abcdef1234567890abcdef" \
  --IpRanges '["0.0.0.0/0"]' \
  --Description "Allows all Ipv4 domain"

# You need Curl version 7.75 or later to use the --aws-sigv4 option

# Example with access key/secret key authentication

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/UpdateApiAccessRule \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "ApiAccessRuleId": "aar-1234567890abcdef1234567890abcdef",
    "IpRanges": ["0.0.0.0/0"],
    "Description": "Allows all Ipv4 domain"
  }'

# Example with login/password authentication

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/UpdateApiAccessRule \
  --header "Authorization: Basic $(echo -n "$OSC_EMAIL:$OSC_PASSWORD" | base64)" \
  --header "X-Osc-Date: $(TZ=GMT date +%Y%m%dT%H%M%SZ)" \
  --header 'Content-Type: application/json' \
  --data '{
    "ApiAccessRuleId": "aar-1234567890abcdef1234567890abcdef",
    "IpRanges": ["0.0.0.0/0"],
    "Description": "Allows all Ipv4 domain"
  }'

from osc_sdk_python import Gateway
# import os

gw = Gateway(**{"profile": "default"})  # For access key/secret key authentication
# gw = Gateway(email=os.environ.get("OSC_EMAIL"), password=os.environ.get("OSC_PASSWORD"))  # For login/password authentication

result = gw.UpdateApiAccessRule(
    ApiAccessRuleId="aar-1234567890abcdef1234567890abcdef",
    IpRanges=["0.0.0.0/0"],
    Description="Allows all Ipv4 domain",
)
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
        /* For login/password authentication, replace the above awsV4SignParameters key with: */
        /* username: process.env.OSC_USERNAME, */
        /* password: process.env.OSC_PASSWORD, */
    });
    const api = new osc.ApiAccessRuleApi(config);

    const result = await api.updateApiAccessRule({
        updateApiAccessRuleRequest: {
            apiAccessRuleId: "aar-1234567890abcdef1234567890abcdef",
            ipRanges: ["0.0.0.0/0"],
            description: "Allows all Ipv4 domain",
        },
    });
    console.log(result);

}

main();

See the outscale_api_access_rule resource in the Terraform OUTSCALE provider.

Body (UpdateApiAccessRuleRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  },
  "ApiAccessRule": {
    "IpRanges": [
      "0.0.0.0/0"
    ],
    "ApiAccessRuleId": "aar-1234567890abcdef1234567890abcdef",
    "CaIds": [],
    "Cns": [],
    "Description": "Allows all IPv4 domain"
  }
}

Response 200 (UpdateApiAccessRuleResponse):

ApiLog

ReadApiLogs

POST /ReadApiLogs

Lists the logs of the API calls you have performed with this account.

[IMPORTANT]
Past logs are accessible for up to 32 days.
By default, the retrieved interval is 48 hours. If neither of the QueryDateBefore nor QueryDateAfter parameters are specified, logs from the past 48 hours are retrieved. If you only specify one of two, logs are retrieved from a 2-day interval based on the date you provided. To retrieve logs beyond a 2-day interval, specify both parameters.

For more information, see About OMS.

Request Parameters

Examples

osc-cli api ReadApiLogs --profile "default" \
  --Filters '{
      "QueryIpAddresses": ["192.0.2.0", "198.51.100.0"],
      "QueryDateAfter": "2017-05-10",
      "QueryDateBefore": "2017-05-10"
    }'

oapi-cli --profile "default" ReadApiLogs \
  --Filters '{
      "QueryIpAddresses": ["192.0.2.0", "198.51.100.0"],
      "QueryDateAfter": "2017-05-10",
      "QueryDateBefore": "2017-05-10"
    }'

# You need Curl version 7.75 or later to use the --aws-sigv4 option

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/ReadApiLogs \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "Filters": {
      "QueryIpAddresses": ["192.0.2.0", "198.51.100.0"],
      "QueryDateAfter": "2017-05-10",
      "QueryDateBefore": "2017-05-10"
    }
  }'

from osc_sdk_python import Gateway

gw = Gateway(**{"profile": "default"})

result = gw.ReadApiLogs(
    Filters={
        "QueryIpAddresses": ["192.0.2.0","198.51.100.0"],
        "QueryDateAfter": "2017-05-10",
        "QueryDateBefore": "2017-05-10",
    },
)
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
    });
    const api = new osc.ApiLogApi(config);

    const result = await api.readApiLogs({
        readApiLogsRequest: {
            filters: {
                queryIpAddresses: ["192.0.2.0", "198.51.100.0"],
                queryDateAfter: "2017-05-10",
                queryDateBefore: "2017-05-10",
            },
        },
    });
    console.log(result);

}

main();

There is no equivalent for this method in the Terraform OUTSCALE provider.

Body (ReadApiLogsRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  },
  "Logs": [
    {
      "ResponseStatusCode": 200,
      "ResponseSize": 1887,
      "QueryPayloadRaw": "{}",
      "QueryApiName": "oapi",
      "QueryIpAddress": "192.0.2.0",
      "QueryUserAgent": "oAPI CLI v0.1 - 2018-09-28",
      "CallDuration": 47,
      "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157",
      "QueryApiVersion": "1.27",
      "AccountId": "123456789012",
      "QueryPayloadSize": 2,
      "QueryCallName": "ReadAccessKeys",
      "QueryAccessKey": "ABCDEFGHIJ0123456789",
      "QueryHeaderSize": 287,
      "QueryDate": "2017-05-10T12:34:56.789Z",
      "QueryHeaderRaw": "Host: api.eu-west-2.outscale.com\\nAccept: */*\\nConnection: close\\nUser-Agent: oAPI CLI v0.1 - 2018-09-28\\nX-Osc-Date: 20170510T000000Z\\nContent-Type: application/json; charset=utf-8\\nAuthorization: *****\\nContent-Length: 2\\nAccept-Encoding: gzip, deflate\\nX-Forwarded-For: 192.0.2.0"
    }
  ]
}

Response 200 (ReadApiLogsResponse):

Ca

CreateCa

POST /CreateCa

Creates a Client Certificate Authority (CA).

For more information, see About API Access Rules.

Request Parameters

Examples

# Example with access key/secret key authentication

osc-cli api CreateCa --profile "default" \
  --CaPem="$(cat ca-certificate.pem)" \
  --Description "CA example"

# Example with login/password authentication

osc-cli api CreateCa --profile "default" --authentication-method "password" --login "$OSC_EMAIL" --password "$OSC_PASSWORD" \
  --CaPem="$(cat ca-certificate.pem)" \
  --Description "CA example"

# Example with access key/secret key authentication

oapi-cli --profile "default" CreateCa \
  --CaPem --file "ca-certificate.pem" \
  --Description "CA example"

# Example with login/password authentication

oapi-cli --profile "default" --login "$OSC_EMAIL" --password "$OSC_PASSWORD" CreateCa \
  --CaPem --file "ca-certificate.pem" \
  --Description "CA example"

# You need Curl version 7.75 or later to use the --aws-sigv4 option

# Example with access key/secret key authentication

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/CreateCa \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "CaPem": "XXXX",
    "Description": "CA example"
  }'

# Example with login/password authentication

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/CreateCa \
  --header "Authorization: Basic $(echo -n "$OSC_EMAIL:$OSC_PASSWORD" | base64)" \
  --header "X-Osc-Date: $(TZ=GMT date +%Y%m%dT%H%M%SZ)" \
  --header 'Content-Type: application/json' \
  --data '{
    "CaPem": "XXXX",
    "Description": "CA example"
  }'

from osc_sdk_python import Gateway
# import os

gw = Gateway(**{"profile": "default"})  # For access key/secret key authentication
# gw = Gateway(email=os.environ.get("OSC_EMAIL"), password=os.environ.get("OSC_PASSWORD"))  # For login/password authentication

result = gw.CreateCa(
    CaPem="XXXX",
    Description="CA example",
)
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
        /* For login/password authentication, replace the above awsV4SignParameters key with: */
        /* username: process.env.OSC_USERNAME, */
        /* password: process.env.OSC_PASSWORD, */
    });
    const api = new osc.CaApi(config);

    const result = await api.createCa({
        createCaRequest: {
            caPem: "XXXX",
            description: "CA example",
        },
    });
    console.log(result);

}

main();

See the outscale_ca resource in the Terraform OUTSCALE provider.

Body (CreateCaRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  },
  "Ca": {
    "Description": "CA example",
    "CaId": "ca-fedcba0987654321fedcba0987654321",
    "CaFingerprint": "1234567890abcdef1234567890abcdef12345678"
  }
}

Response 200 (CreateCaResponse):

DeleteCa

POST /DeleteCa

Deletes a specified Client Certificate Authority (CA).

Request Parameters

Examples

# Example with access key/secret key authentication

osc-cli api DeleteCa --profile "default" \
  --CaId "ca-fedcba0987654321fedcba0987654321"

# Example with login/password authentication

osc-cli api DeleteCa --profile "default" --authentication-method "password" --login "$OSC_EMAIL" --password "$OSC_PASSWORD" \
  --CaId "ca-fedcba0987654321fedcba0987654321"

# Example with access key/secret key authentication

oapi-cli --profile "default" DeleteCa \
  --CaId "ca-fedcba0987654321fedcba0987654321"

# Example with login/password authentication

oapi-cli --profile "default" --login "$OSC_EMAIL" --password "$OSC_PASSWORD" DeleteCa \
  --CaId "ca-fedcba0987654321fedcba0987654321"

# You need Curl version 7.75 or later to use the --aws-sigv4 option

# Example with access key/secret key authentication

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/DeleteCa \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "CaId": "ca-fedcba0987654321fedcba0987654321"
  }'

# Example with login/password authentication

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/DeleteCa \
  --header "Authorization: Basic $(echo -n "$OSC_EMAIL:$OSC_PASSWORD" | base64)" \
  --header "X-Osc-Date: $(TZ=GMT date +%Y%m%dT%H%M%SZ)" \
  --header 'Content-Type: application/json' \
  --data '{
    "CaId": "ca-fedcba0987654321fedcba0987654321"
  }'

from osc_sdk_python import Gateway
# import os

gw = Gateway(**{"profile": "default"})  # For access key/secret key authentication
# gw = Gateway(email=os.environ.get("OSC_EMAIL"), password=os.environ.get("OSC_PASSWORD"))  # For login/password authentication

result = gw.DeleteCa(
    CaId="ca-fedcba0987654321fedcba0987654321",
)
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
        /* For login/password authentication, replace the above awsV4SignParameters key with: */
        /* username: process.env.OSC_USERNAME, */
        /* password: process.env.OSC_PASSWORD, */
    });
    const api = new osc.CaApi(config);

    const result = await api.deleteCa({
        deleteCaRequest: {
            caId: "ca-fedcba0987654321fedcba0987654321",
        },
    });
    console.log(result);

}

main();

See the outscale_ca resource in the Terraform OUTSCALE provider.

Body (DeleteCaRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  }
}

Response 200 (DeleteCaResponse):

ReadCas

POST /ReadCas

Gets information about one or more of your Client Certificate Authorities (CAs).

Request Parameters

Examples

# Example with access key/secret key authentication

osc-cli api ReadCas --profile "default" \
  --Filters '{
      "CaIds": ["ca-fedcba0987654321fedcba0987654321"]
    }'

# Example with login/password authentication

osc-cli api ReadCas --profile "default" --authentication-method "password" --login "$OSC_EMAIL" --password "$OSC_PASSWORD" \
  --Filters '{
      "CaIds": ["ca-fedcba0987654321fedcba0987654321"]
    }'

# Example with access key/secret key authentication

oapi-cli --profile "default" ReadCas \
  --Filters '{
      "CaIds": ["ca-fedcba0987654321fedcba0987654321"]
    }'

# Example with login/password authentication

oapi-cli --profile "default" --login "$OSC_EMAIL" --password "$OSC_PASSWORD" ReadCas \
  --Filters '{
      "CaIds": ["ca-fedcba0987654321fedcba0987654321"]
    }'

# You need Curl version 7.75 or later to use the --aws-sigv4 option

# Example with access key/secret key authentication

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/ReadCas \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "Filters": {
      "CaIds": ["ca-fedcba0987654321fedcba0987654321"]
    }
  }'

# Example with login/password authentication

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/ReadCas \
  --header "Authorization: Basic $(echo -n "$OSC_EMAIL:$OSC_PASSWORD" | base64)" \
  --header "X-Osc-Date: $(TZ=GMT date +%Y%m%dT%H%M%SZ)" \
  --header 'Content-Type: application/json' \
  --data '{
    "Filters": {
      "CaIds": ["ca-fedcba0987654321fedcba0987654321"]
    }
  }'

from osc_sdk_python import Gateway
# import os

gw = Gateway(**{"profile": "default"})  # For access key/secret key authentication
# gw = Gateway(email=os.environ.get("OSC_EMAIL"), password=os.environ.get("OSC_PASSWORD"))  # For login/password authentication

result = gw.ReadCas(
    Filters={
        "CaIds": ["ca-fedcba0987654321fedcba0987654321"],
    },
)
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
        /* For login/password authentication, replace the above awsV4SignParameters key with: */
        /* username: process.env.OSC_USERNAME, */
        /* password: process.env.OSC_PASSWORD, */
    });
    const api = new osc.CaApi(config);

    const result = await api.readCas({
        readCasRequest: {
            filters: {
                caIds: ["ca-fedcba0987654321fedcba0987654321"],
            },
        },
    });
    console.log(result);

}

main();

See the outscale_ca or outscale_cas data sources in the Terraform OUTSCALE provider.

Body (ReadCasRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  },
  "Cas": [
    {
      "Description": "CA example",
      "CaId": "ca-fedcba0987654321fedcba0987654321",
      "CaFingerprint": "1234567890abcdef1234567890abcdef12345678"
    }
  ]
}

Response 200 (ReadCasResponse):

UpdateCa

POST /UpdateCa

Modifies the specified attribute of a Client Certificate Authority (CA).

Request Parameters

Examples

# Example with access key/secret key authentication

osc-cli api UpdateCa --profile "default" \
  --CaId "ca-fedcba0987654321fedcba0987654321" \
  --Description "New description"

# Example with login/password authentication

osc-cli api UpdateCa --profile "default" --authentication-method "password" --login "$OSC_EMAIL" --password "$OSC_PASSWORD" \
  --CaId "ca-fedcba0987654321fedcba0987654321" \
  --Description "New description"

# Example with access key/secret key authentication

oapi-cli --profile "default" UpdateCa \
  --CaId "ca-fedcba0987654321fedcba0987654321" \
  --Description "New description"

# Example with login/password authentication

oapi-cli --profile "default" --login "$OSC_EMAIL" --password "$OSC_PASSWORD" UpdateCa \
  --CaId "ca-fedcba0987654321fedcba0987654321" \
  --Description "New description"

# You need Curl version 7.75 or later to use the --aws-sigv4 option

# Example with access key/secret key authentication

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/UpdateCa \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "CaId": "ca-fedcba0987654321fedcba0987654321",
    "Description": "New description"
  }'

# Example with login/password authentication

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/UpdateCa \
  --header "Authorization: Basic $(echo -n "$OSC_EMAIL:$OSC_PASSWORD" | base64)" \
  --header "X-Osc-Date: $(TZ=GMT date +%Y%m%dT%H%M%SZ)" \
  --header 'Content-Type: application/json' \
  --data '{
    "CaId": "ca-fedcba0987654321fedcba0987654321",
    "Description": "New description"
  }'

from osc_sdk_python import Gateway
# import os

gw = Gateway(**{"profile": "default"})  # For access key/secret key authentication
# gw = Gateway(email=os.environ.get("OSC_EMAIL"), password=os.environ.get("OSC_PASSWORD"))  # For login/password authentication

result = gw.UpdateCa(
    CaId="ca-fedcba0987654321fedcba0987654321",
    Description="New description",
)
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
        /* For login/password authentication, replace the above awsV4SignParameters key with: */
        /* username: process.env.OSC_USERNAME, */
        /* password: process.env.OSC_PASSWORD, */
    });
    const api = new osc.CaApi(config);

    const result = await api.updateCa({
        updateCaRequest: {
            caId: "ca-fedcba0987654321fedcba0987654321",
            description: "New description",
        },
    });
    console.log(result);

}

main();

See the outscale_ca resource in the Terraform OUTSCALE provider.

Body (UpdateCaRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  },
  "Ca": {
    "Description": "New description",
    "CaId": "ca-fedcba0987654321fedcba0987654321",
    "CaFingerprint": "1234567890abcdef1234567890abcdef12345678"
  }
}

Response 200 (UpdateCaResponse):

Catalog

ReadCatalog

POST /ReadCatalog

Returns the price list of OUTSCALE services for the current Region.

Request Parameters

Examples

osc-cli api ReadCatalog --profile "default"

oapi-cli --profile "default" ReadCatalog

# You need Curl version 7.75 or later to use the --aws-sigv4 option

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/ReadCatalog \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{}'

from osc_sdk_python import Gateway

gw = Gateway(**{"profile": "default"})

result = gw.ReadCatalog()
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
    });
    const api = new osc.CatalogApi(config);

    const result = await api.readCatalog({
        readCatalogRequest: {},
    });
    console.log(result);

}

main();

There is no equivalent for this method in the Terraform OUTSCALE provider.

Body (ReadCatalogRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  },
  "Catalog": {
    "Entries": [
      {
        "UnitPrice": 0.04,
        "Type": "CustomCore:v5-p1",
        "Title": "Instance - On demand - Unite de vCore pour une instance Tina v5 CxRy Performance highest - par heure",
        "SubregionName": "eu-west-2",
        "Category": "compute",
        "Service": "TinaOS-FCU",
        "Operation": "RunInstances-OD"
      }
    ]
  }
}

Response 200 (ReadCatalogResponse):

ReadCatalogs

POST /ReadCatalogs

Returns the price list of OUTSCALE services for the current Region within a specific time period.

Request Parameters

Examples

osc-cli api ReadCatalogs --profile "default" \
  --Filters '{
      "CurrentCatalogOnly": True,
      "FromDate": "2021-01-01",
      "ToDate": "2023-01-01"
    }'

oapi-cli --profile "default" ReadCatalogs \
  --Filters '{
      "CurrentCatalogOnly": True,
      "FromDate": "2021-01-01",
      "ToDate": "2023-01-01"
    }'

# You need Curl version 7.75 or later to use the --aws-sigv4 option

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/ReadCatalogs \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "Filters": {
      "CurrentCatalogOnly": true,
      "FromDate": "2021-01-01",
      "ToDate": "2023-01-01"
    }
  }'

from osc_sdk_python import Gateway

gw = Gateway(**{"profile": "default"})

result = gw.ReadCatalogs(
    Filters={
        "CurrentCatalogOnly": True,
        "FromDate": "2021-01-01",
        "ToDate": "2023-01-01",
    },
)
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
    });
    const api = new osc.CatalogApi(config);

    const result = await api.readCatalogs({
        readCatalogsRequest: {
            filters: {
                currentCatalogOnly: true,
                fromDate: "2021-01-01",
                toDate: "2023-01-01",
            },
        },
    });
    console.log(result);

}

main();

There is no equivalent for this method in the Terraform OUTSCALE provider.

Body (ReadCatalogsRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  },
  "Catalogs": [
    {
      "State": "CURRENT",
      "FromDate": "2021-01-01T00:00:00.000+0000",
      "Entries": [
        {
          "UnitPrice": 0.04,
          "Type": "CustomCore:v5-p1",
          "Title": "Instance - On demand - Unite de vCore pour une instance Tina v5 CxRy Performance highest - par heure",
          "SubregionName": "eu-west-2",
          "Category": "compute",
          "Service": "TinaOS-FCU",
          "Operation": "RunInstances-OD"
        }
      ]
    }
  ]
}

Response 200 (ReadCatalogsResponse):

ReadUnitPrice

POST /ReadUnitPrice

Gets unit price information for the specified parameters.

Request Parameters

Examples

osc-cli api ReadUnitPrice --profile "default" \
  --Operation "CreateVolume" \
  --Service "TinaOS-FCU" \
  --Type "BSU:VolumeIOPS:io1"

oapi-cli --profile "default" ReadUnitPrice \
  --Operation "CreateVolume" \
  --Service "TinaOS-FCU" \
  --Type "BSU:VolumeIOPS:io1"

# You need Curl version 7.75 or later to use the --aws-sigv4 option

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/ReadUnitPrice \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "Operation": "CreateVolume",
    "Service": "TinaOS-FCU",
    "Type": "BSU:VolumeIOPS:io1"
  }'

from osc_sdk_python import Gateway

gw = Gateway(**{"profile": "default"})

result = gw.ReadUnitPrice(
    Operation="CreateVolume",
    Service="TinaOS-FCU",
    Type="BSU:VolumeIOPS:io1",
)
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
    });
    const api = new osc.CatalogApi(config);

    const result = await api.readUnitPrice({
        readUnitPriceRequest: {
            operation: "CreateVolume",
            service: "TinaOS-FCU",
            type: "BSU:VolumeIOPS:io1",
        },
    });
    console.log(result);

}

main();

There is no equivalent for this method in the Terraform OUTSCALE provider.

Body (ReadUnitPriceRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  },
  "UnitPriceEntry": {
    "UnitPrice": 0.01,
    "Unit": "PER_IOPS_PER_MONTH",
    "Currency": "EUR",
    "Operation": "CreateVolume",
    "Type": "BSU:VolumeIOPS:io1",
    "Service": "TinaOS-FCU"
  }
}

Response 200 (ReadUnitPriceResponse):

ClientGateway

CreateClientGateway

POST /CreateClientGateway

Provides information about your client gateway.
This action registers information to identify the client gateway that you deployed in your network.
To open a tunnel to the client gateway, you must provide the communication protocol type, the fixed public IP of the gateway, and an Autonomous System Number (ASN).

For more information, see About Client Gateways.

Request Parameters

Examples

osc-cli api CreateClientGateway --profile "default" \
  --ConnectionType "ipsec.1" \
  --PublicIp "192.0.2.0" \
  --BgpAsn 65000

oapi-cli --profile "default" CreateClientGateway \
  --ConnectionType "ipsec.1" \
  --PublicIp "192.0.2.0" \
  --BgpAsn 65000

# You need Curl version 7.75 or later to use the --aws-sigv4 option

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/CreateClientGateway \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "ConnectionType": "ipsec.1",
    "PublicIp": "192.0.2.0",
    "BgpAsn": 65000
  }'

from osc_sdk_python import Gateway

gw = Gateway(**{"profile": "default"})

result = gw.CreateClientGateway(
    ConnectionType="ipsec.1",
    PublicIp="192.0.2.0",
    BgpAsn=65000,
)
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
    });
    const api = new osc.ClientGatewayApi(config);

    const result = await api.createClientGateway({
        createClientGatewayRequest: {
            connectionType: "ipsec.1",
            publicIp: "192.0.2.0",
            bgpAsn: 65000,
        },
    });
    console.log(result);

}

main();

See the outscale_client_gateway resource in the Terraform OUTSCALE provider.

Body (CreateClientGatewayRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  },
  "ClientGateway": {
    "State": "available",
    "BgpAsn": 65000,
    "Tags": [],
    "ClientGatewayId": "cgw-12345678",
    "ConnectionType": "ipsec.1",
    "PublicIp": "192.0.2.0"
  }
}

Response 200 (CreateClientGatewayResponse):

DeleteClientGateway

POST /DeleteClientGateway

Deletes a client gateway.
You must delete the VPN connection before deleting the client gateway.

Request Parameters

Examples

osc-cli api DeleteClientGateway --profile "default" \
  --ClientGatewayId "cgw-12345678"

oapi-cli --profile "default" DeleteClientGateway \
  --ClientGatewayId "cgw-12345678"

# You need Curl version 7.75 or later to use the --aws-sigv4 option

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/DeleteClientGateway \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "ClientGatewayId": "cgw-12345678"
  }'

from osc_sdk_python import Gateway

gw = Gateway(**{"profile": "default"})

result = gw.DeleteClientGateway(
    ClientGatewayId="cgw-12345678",
)
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
    });
    const api = new osc.ClientGatewayApi(config);

    const result = await api.deleteClientGateway({
        deleteClientGatewayRequest: {
            clientGatewayId: "cgw-12345678",
        },
    });
    console.log(result);

}

main();

See the outscale_client_gateway resource in the Terraform OUTSCALE provider.

Body (DeleteClientGatewayRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  }
}

Response 200 (DeleteClientGatewayResponse):

ReadClientGateways

POST /ReadClientGateways

Lists one or more of your client gateways.

Request Parameters

Examples

osc-cli api ReadClientGateways --profile "default" \
  --Filters '{
      "ClientGatewayIds": ["cgw-12345678"]
    }'

osc-cli api ReadClientGateways --profile "default" \
  --Filters '{
      "BgpAsns": [65000],
      "PublicIps": ["192.0.2.0", "198.51.100.0"]
    }'

oapi-cli --profile "default" ReadClientGateways \
  --Filters '{
      "ClientGatewayIds": ["cgw-12345678"]
    }'

oapi-cli --profile "default" ReadClientGateways \
  --Filters '{
      "BgpAsns": [65000],
      "PublicIps": ["192.0.2.0", "198.51.100.0"]
    }'

# You need Curl version 7.75 or later to use the --aws-sigv4 option

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/ReadClientGateways \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "Filters": {
      "ClientGatewayIds": ["cgw-12345678"]
    }
  }'

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/ReadClientGateways \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "Filters": {
      "BgpAsns": [65000],
      "PublicIps": ["192.0.2.0", "198.51.100.0"]
    }
  }'

from osc_sdk_python import Gateway

gw = Gateway(**{"profile": "default"})

result = gw.ReadClientGateways(
    Filters={
        "ClientGatewayIds": ["cgw-12345678"],
    },
)
print(result)

result = gw.ReadClientGateways(
    Filters={
        "BgpAsns": [65000],
        "PublicIps": ["192.0.2.0","198.51.100.0"],
    },
)
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
    });
    const api = new osc.ClientGatewayApi(config);

    const result = await api.readClientGateways({
        readClientGatewaysRequest: {
            filters: {
                clientGatewayIds: ["cgw-12345678"],
            },
        },
    });
    console.log(result);

    const result2 = await api.readClientGateways({
        readClientGatewaysRequest: {
            filters: {
                bgpAsns: [65000],
                publicIps: ["192.0.2.0", "198.51.100.0"],
            },
        },
    });
    console.log(result2);

}

main();

See the outscale_client_gateway or outscale_client_gateways data sources in the Terraform OUTSCALE provider.

Body (ReadClientGatewaysRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  },
  "ClientGateways": [
    {
      "State": "available",
      "BgpAsn": 65000,
      "Tags": [],
      "ClientGatewayId": "cgw-12345678",
      "ConnectionType": "ipsec.1",
      "PublicIp": "192.0.2.0"
    }
  ]
}

Response 200 (ReadClientGatewaysResponse):

DedicatedGroup

CreateDedicatedGroup

POST /CreateDedicatedGroup

[WARNING]
This feature is currently in beta.

Creates a dedicated group for virtual machines (VMs).

For more information, see About Dedicated Groups.

Request Parameters

Examples

osc-cli api CreateDedicatedGroup --profile "default" \
  --CpuGeneration 4 \
  --Name "dedicated-group-example" \
  --SubregionName "eu-west-2a"

oapi-cli --profile "default" CreateDedicatedGroup \
  --CpuGeneration 4 \
  --Name "dedicated-group-example" \
  --SubregionName "eu-west-2a"

# You need Curl version 7.75 or later to use the --aws-sigv4 option

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/CreateDedicatedGroup \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "CpuGeneration": 4,
    "Name": "dedicated-group-example",
    "SubregionName": "eu-west-2a"
  }'

from osc_sdk_python import Gateway

gw = Gateway(**{"profile": "default"})

result = gw.CreateDedicatedGroup(
    CpuGeneration=4,
    Name="dedicated-group-example",
    SubregionName="eu-west-2a",
)
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
    });
    const api = new osc.DedicatedGroupApi(config);

    const result = await api.createDedicatedGroup({
        createDedicatedGroupRequest: {
            cpuGeneration: 4,
            name: "dedicated-group-example",
            subregionName: "eu-west-2a",
        },
    });
    console.log(result);

}

main();

There is no equivalent for this method in the Terraform OUTSCALE provider.

Body (CreateDedicatedGroupRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  },
  "DedicatedGroup": {
    "VmIds": [],
    "NetIds": [],
    "AccountId": "123456789012",
    "CpuGeneration": 4,
    "Name": "dedicated-group-example",
    "SubregionName": "eu-west-2a",
    "DedicatedGroupId": "ded-12345678"
  }
}

Response 200 (CreateDedicatedGroupResponse):

Other responses:

• Response 400 (ErrorResponse): The HTTP 400 response (Bad Request).
• Response 401 (ErrorResponse): The HTTP 401 response (Unauthorized).
• Response 500 (ErrorResponse): The HTTP 500 response (Internal Server Error).

DeleteDedicatedGroup

POST /DeleteDedicatedGroup

[WARNING]
This feature is currently in beta.

Deletes a specified dedicated group of virtual machines (VMs).

[WARNING]
A dedicated group can be deleted only if no VM or Net is in the dedicated group. Otherwise, you need to force the deletion.
If you force the deletion:

• all VMs are terminated.
  
• all Nets are deleted, and all resources associated with Nets are detached.

Request Parameters

Examples

# Deleting a dedicated group without any resource in it.

osc-cli api DeleteDedicatedGroup --profile "default" \
  --DedicatedGroupId "ded-12345678"

# Forcing the deletion of a dedicated group and all resources in it.

osc-cli api DeleteDedicatedGroup --profile "default" \
  --DedicatedGroupId "ded-12345678" \
  --Force True

# Deleting a dedicated group without any resource in it.

oapi-cli --profile "default" DeleteDedicatedGroup \
  --DedicatedGroupId "ded-12345678"

# Forcing the deletion of a dedicated group and all resources in it.

oapi-cli --profile "default" DeleteDedicatedGroup \
  --DedicatedGroupId "ded-12345678" \
  --Force True

# You need Curl version 7.75 or later to use the --aws-sigv4 option

# Deleting a dedicated group without any resource in it.

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/DeleteDedicatedGroup \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "DedicatedGroupId": "ded-12345678"
  }'

# Forcing the deletion of a dedicated group and all resources in it.

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/DeleteDedicatedGroup \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "DedicatedGroupId": "ded-12345678",
    "Force": true
  }'

from osc_sdk_python import Gateway

gw = Gateway(**{"profile": "default"})

# Deleting a dedicated group without any resource in it.
result = gw.DeleteDedicatedGroup(
    DedicatedGroupId="ded-12345678",
)
print(result)

# Forcing the deletion of a dedicated group and all resources in it.
result = gw.DeleteDedicatedGroup(
    DedicatedGroupId="ded-12345678",
    Force=True,
)
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
    });
    const api = new osc.DedicatedGroupApi(config);

    /* Deleting a dedicated group without any resource in it. */
    const result = await api.deleteDedicatedGroup({
        deleteDedicatedGroupRequest: {
            dedicatedGroupId: "ded-12345678",
        },
    });
    console.log(result);

    /* Forcing the deletion of a dedicated group and all resources in it. */
    const result2 = await api.deleteDedicatedGroup({
        deleteDedicatedGroupRequest: {
            dedicatedGroupId: "ded-12345678",
            force: true,
        },
    });
    console.log(result2);

}

main();

There is no equivalent for this method in the Terraform OUTSCALE provider.

Body (DeleteDedicatedGroupRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  }
}

Response 200 (DeleteDedicatedGroupResponse):

Other responses:

• Response 400 (ErrorResponse): The HTTP 400 response (Bad Request).
• Response 401 (ErrorResponse): The HTTP 401 response (Unauthorized).
• Response 500 (ErrorResponse): The HTTP 500 response (Internal Server Error).

ReadDedicatedGroups

POST /ReadDedicatedGroups

[WARNING]
This feature is currently in beta.

List one or more dedicated groups of virtual machines (VMs).

Request Parameters

Examples

# Filtering on a specific dedicated group

osc-cli api ReadDedicatedGroups --profile "default" \
  --Filters '{
      "DedicatedGroupIds": ["ded-12345678"]
    }'

# Filtering on a specific Subregion and CPU generation

osc-cli api ReadDedicatedGroups --profile "default" \
  --Filters '{
      "SubregionNames": ["eu-west-2a"],
      "CpuGenerations": [4]
    }'

# Filtering on a specific dedicated group

oapi-cli --profile "default" ReadDedicatedGroups \
  --Filters '{
      "DedicatedGroupIds": ["ded-12345678"]
    }'

# Filtering on a specific Subregion and CPU generation

oapi-cli --profile "default" ReadDedicatedGroups \
  --Filters '{
      "SubregionNames": ["eu-west-2a"],
      "CpuGenerations": [4]
    }'

# You need Curl version 7.75 or later to use the --aws-sigv4 option

# Filtering on a specific dedicated group

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/ReadDedicatedGroups \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "Filters": {
      "DedicatedGroupIds": ["ded-12345678"]
    }
  }'

# Filtering on a specific Subregion and CPU generation

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/ReadDedicatedGroups \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "Filters": {
      "SubregionNames": ["eu-west-2a"],
      "CpuGenerations": [4]
    }
  }'

from osc_sdk_python import Gateway

gw = Gateway(**{"profile": "default"})

# Filtering on a specific dedicated group
result = gw.ReadDedicatedGroups(
    Filters={
        "DedicatedGroupIds": ["ded-12345678"],
    },
)
print(result)

# Filtering on a specific Subregion and CPU generation
result = gw.ReadDedicatedGroups(
    Filters={
        "SubregionNames": ["eu-west-2a"],
        "CpuGenerations": [4],
    },
)
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
    });
    const api = new osc.DedicatedGroupApi(config);

    /* Filtering on a specific dedicated group */
    const result = await api.readDedicatedGroups({
        readDedicatedGroupsRequest: {
            filters: {
                dedicatedGroupIds: ["ded-12345678"],
            },
        },
    });
    console.log(result);

    /* Filtering on a specific Subregion and CPU generation */
    const result2 = await api.readDedicatedGroups({
        readDedicatedGroupsRequest: {
            filters: {
                subregionNames: ["eu-west-2a"],
                cpuGenerations: [4],
            },
        },
    });
    console.log(result2);

}

main();

There is no equivalent for this method in the Terraform OUTSCALE provider.

Body (ReadDedicatedGroupsRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  },
  "DedicatedGroups": [
    {
      "VmIds": [
        "i-12345678"
      ],
      "NetIds": [],
      "AccountId": "123456789012",
      "CpuGeneration": 4,
      "Name": "dedicated-group-example",
      "SubregionName": "eu-west-2a",
      "DedicatedGroupId": "ded-12345678"
    }
  ]
}

Response 200 (ReadDedicatedGroupsResponse):

Other responses:

• Response 400 (ErrorResponse): The HTTP 400 response (Bad Request).
• Response 401 (ErrorResponse): The HTTP 401 response (Unauthorized).
• Response 500 (ErrorResponse): The HTTP 500 response (Internal Server Error).

UpdateDedicatedGroup

POST /UpdateDedicatedGroup

[WARNING]
This feature is currently in beta.

Modifies the name of a specified dedicated group.

Request Parameters

Examples

osc-cli api UpdateDedicatedGroup --profile "default" \
  --DedicatedGroupId "ded-12345678" \
  --Name "New-dedicated-group-name"

oapi-cli --profile "default" UpdateDedicatedGroup \
  --DedicatedGroupId "ded-12345678" \
  --Name "New-dedicated-group-name"

# You need Curl version 7.75 or later to use the --aws-sigv4 option

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/UpdateDedicatedGroup \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "DedicatedGroupId": "ded-12345678",
    "Name": "New-dedicated-group-name"
  }'

from osc_sdk_python import Gateway

gw = Gateway(**{"profile": "default"})

result = gw.UpdateDedicatedGroup(
    DedicatedGroupId="ded-12345678",
    Name="New-dedicated-group-name",
)
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
    });
    const api = new osc.DedicatedGroupApi(config);

    const result = await api.updateDedicatedGroup({
        updateDedicatedGroupRequest: {
            dedicatedGroupId: "ded-12345678",
            name: "New-dedicated-group-name",
        },
    });
    console.log(result);

}

main();

There is no equivalent for this method in the Terraform OUTSCALE provider.

Body (UpdateDedicatedGroupRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  },
  "DedicatedGroup": {
    "VmIds": [
      "i-12345678"
    ],
    "NetIds": [
      "vpc-12345678"
    ],
    "AccountId": "123456789012",
    "CpuGeneration": 4,
    "Name": "New-dedicated-group-name",
    "SubregionName": "eu-west-2a",
    "DedicatedGroupId": "ded-12345678"
  }
}

Response 200 (UpdateDedicatedGroupResponse):

Other responses:

• Response 400 (ErrorResponse): The HTTP 400 response (Bad Request).
• Response 401 (ErrorResponse): The HTTP 401 response (Unauthorized).
• Response 500 (ErrorResponse): The HTTP 500 response (Internal Server Error).

DhcpOption

CreateDhcpOptions

POST /CreateDhcpOptions

Creates a set of DHCP options, that you can then associate with a Net using the UpdateNet method.

For more information, see About DHCP Options.

Request Parameters

Examples

osc-cli api CreateDhcpOptions --profile "default" \
  --DomainName "example.com" \
  --DomainNameServers '["192.0.2.0", "198.51.100.0"]' \
  --NtpServers '["203.0.113.0", "203.0.113.1"]'

oapi-cli --profile "default" CreateDhcpOptions \
  --DomainName "example.com" \
  --DomainNameServers '["192.0.2.0", "198.51.100.0"]' \
  --NtpServers '["203.0.113.0", "203.0.113.1"]'

# You need Curl version 7.75 or later to use the --aws-sigv4 option

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/CreateDhcpOptions \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "DomainName": "example.com",
    "DomainNameServers": ["192.0.2.0", "198.51.100.0"],
    "NtpServers": ["203.0.113.0", "203.0.113.1"]
  }'

from osc_sdk_python import Gateway

gw = Gateway(**{"profile": "default"})

result = gw.CreateDhcpOptions(
    DomainName="example.com",
    DomainNameServers=["192.0.2.0","198.51.100.0"],
    NtpServers=["203.0.113.0","203.0.113.1"],
)
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
    });
    const api = new osc.DhcpOptionApi(config);

    const result = await api.createDhcpOptions({
        createDhcpOptionsRequest: {
            domainName: "example.com",
            domainNameServers: ["192.0.2.0", "198.51.100.0"],
            ntpServers: ["203.0.113.0", "203.0.113.1"],
        },
    });
    console.log(result);

}

main();

See the outscale_dhcp_option resource in the Terraform OUTSCALE provider.

Body (CreateDhcpOptionsRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  },
  "DhcpOptionsSet": {
    "Tags": [],
    "NtpServers": [
      "203.0.113.0",
      "203.0.113.1"
    ],
    "Default": false,
    "DhcpOptionsSetId": "dopt-12345678",
    "DomainName": "example.com",
    "DomainNameServers": [
      "192.0.2.0",
      "198.51.100.0"
    ]
  }
}

Response 200 (CreateDhcpOptionsResponse):

DeleteDhcpOptions

POST /DeleteDhcpOptions

Deletes a specified DHCP options set.
Before deleting a DHCP options set, you must disassociate it from the Nets you associated it with. To do so, you need to associate with each Net a new set of DHCP options, or the default one if you do not want to associate any DHCP options with the Net.

[IMPORTANT]
You cannot delete the default set.

Request Parameters

Examples

osc-cli api DeleteDhcpOptions --profile "default" \
  --DhcpOptionsSetId "dopt-12345678"

oapi-cli --profile "default" DeleteDhcpOptions \
  --DhcpOptionsSetId "dopt-12345678"

# You need Curl version 7.75 or later to use the --aws-sigv4 option

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/DeleteDhcpOptions \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "DhcpOptionsSetId": "dopt-12345678"
  }'

from osc_sdk_python import Gateway

gw = Gateway(**{"profile": "default"})

result = gw.DeleteDhcpOptions(
    DhcpOptionsSetId="dopt-12345678",
)
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
    });
    const api = new osc.DhcpOptionApi(config);

    const result = await api.deleteDhcpOptions({
        deleteDhcpOptionsRequest: {
            dhcpOptionsSetId: "dopt-12345678",
        },
    });
    console.log(result);

}

main();

See the outscale_dhcp_option resource in the Terraform OUTSCALE provider.

Body (DeleteDhcpOptionsRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  }
}

Response 200 (DeleteDhcpOptionsResponse):

ReadDhcpOptions

POST /ReadDhcpOptions

Gets information about the content of one or more DHCP options sets.

Request Parameters

Examples

osc-cli api ReadDhcpOptions --profile "default" \
  --Filters '{
      "DhcpOptionsSetIds": ["dopt-12345678"]
    }'

osc-cli api ReadDhcpOptions --profile "default" \
  --Filters '{
      "DomainNameServers": ["192.0.2.0", "198.51.100.0"],
      "DomainNames": ["example.com"]
    }'

oapi-cli --profile "default" ReadDhcpOptions \
  --Filters '{
      "DhcpOptionsSetIds": ["dopt-12345678"]
    }'

oapi-cli --profile "default" ReadDhcpOptions \
  --Filters '{
      "DomainNameServers": ["192.0.2.0", "198.51.100.0"],
      "DomainNames": ["example.com"]
    }'

# You need Curl version 7.75 or later to use the --aws-sigv4 option

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/ReadDhcpOptions \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "Filters": {
      "DhcpOptionsSetIds": ["dopt-12345678"]
    }
  }'

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/ReadDhcpOptions \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "Filters": {
      "DomainNameServers": ["192.0.2.0", "198.51.100.0"],
      "DomainNames": ["example.com"]
    }
  }'

from osc_sdk_python import Gateway

gw = Gateway(**{"profile": "default"})

result = gw.ReadDhcpOptions(
    Filters={
        "DhcpOptionsSetIds": ["dopt-12345678"],
    },
)
print(result)

result = gw.ReadDhcpOptions(
    Filters={
        "DomainNameServers": ["192.0.2.0","198.51.100.0"],
        "DomainNames": ["example.com"],
    },
)
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
    });
    const api = new osc.DhcpOptionApi(config);

    const result = await api.readDhcpOptions({
        readDhcpOptionsRequest: {
            filters: {
                dhcpOptionsSetIds: ["dopt-12345678"],
            },
        },
    });
    console.log(result);

    const result2 = await api.readDhcpOptions({
        readDhcpOptionsRequest: {
            filters: {
                domainNameServers: ["192.0.2.0", "198.51.100.0"],
                domainNames: ["example.com"],
            },
        },
    });
    console.log(result2);

}

main();

See the outscale_dhcp_option or outscale_dhcp_options data sources in the Terraform OUTSCALE provider.

Body (ReadDhcpOptionsRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  },
  "DhcpOptionsSets": [
    {
      "Tags": [],
      "NtpServers": [
        "203.0.113.0",
        "203.0.113.1"
      ],
      "Default": false,
      "DhcpOptionsSetId": "dopt-12345678",
      "DomainName": "example.com",
      "DomainNameServers": [
        "192.0.2.0",
        "198.51.100.0"
      ]
    }
  ]
}

Response 200 (ReadDhcpOptionsResponse):

DirectLink

CreateDirectLink

POST /CreateDirectLink

Creates a DirectLink between a customer network and a specified DirectLink location.

For more information, see About DirectLink.

Request Parameters

Examples

osc-cli api CreateDirectLink --profile "default" \
  --Location "PAR1" \
  --Bandwidth "1Gbps" \
  --DirectLinkName "Connection to Outscale"

oapi-cli --profile "default" CreateDirectLink \
  --Location "PAR1" \
  --Bandwidth "1Gbps" \
  --DirectLinkName "Connection to Outscale"

# You need Curl version 7.75 or later to use the --aws-sigv4 option

curl -X POST https://api.$OSC_REGION.outscale.com/api/v1/CreateDirectLink \
  --user $OSC_ACCESS_KEY:$OSC_SECRET_KEY \
  --aws-sigv4 'osc' \
  --header 'Content-Type: application/json' \
  --data '{
    "Location": "PAR1",
    "Bandwidth": "1Gbps",
    "DirectLinkName": "Connection to Outscale"
  }'

from osc_sdk_python import Gateway

gw = Gateway(**{"profile": "default"})

result = gw.CreateDirectLink(
    Location="PAR1",
    Bandwidth="1Gbps",
    DirectLinkName="Connection to Outscale",
)
print(result)

const osc = require("outscale-api");
const crypto = require("crypto");
global.crypto = crypto.webcrypto;

async function main() {
    const config = new osc.Configuration({
        basePath: "https://api." + process.env.OSC_REGION + ".outscale.com/api/v1",
        awsV4SignParameters: {
            accessKeyId: process.env.OSC_ACCESS_KEY,
            secretAccessKey: process.env.OSC_SECRET_KEY,
            service: "api",
        },
    });
    const api = new osc.DirectLinkApi(config);

    const result = await api.createDirectLink({
        createDirectLinkRequest: {
            location: "PAR1",
            bandwidth: "1Gbps",
            directLinkName: "Connection to Outscale",
        },
    });
    console.log(result);

}

main();

There is no equivalent for this method in the Terraform OUTSCALE provider.

Body (CreateDirectLinkRequest):

Response Elements

Examples

{
  "ResponseContext": {
    "RequestId": "0475ca1e-d0c5-441d-712a-da55a4175157"
  },
  "DirectLink": {
    "AccountId": "123456789012",
    "Bandwidth": "1Gbps",
    "DirectLinkId": "dxcon-12345678",
    "DirectLinkName": "Connection to Outscale",
    "Location": "PAR1",
    "RegionName": "eu-west-2",
    "State": "requested"
  }
}

Response 200 (CreateDirectLinkResponse):