SDK Go OUTSCALE

Le SDK Go OUTSCALE vous permet d’interagir avec les ressources du Cloud OUTSCALE directement depuis vos applications Go. Il fournit un client Go typé pour l’API OUTSCALE, ainsi que la sérialisation JSON, l’authentification et la gestion des erreurs.

Pour utiliser ce SDK, vous devez disposer : * d’un compte OUTSCALE * d’identifiants valides * d’un accès réseau aux endpoints de l’API OUTSCALE.

Installation

Avant de commencer : Assurez-vous que Go 1.24 ou une version ultérieure est installé sur votre machine.

Le SDK est disponible sous la forme d’un module Go. Pour l’installer, exécutez la commande suivante :

$ go get github.com/outscale/osc-sdk-go/v3

Cette commande ajoute la dépendance du SDK à votre fichier go.mod.

Configuration de l’accès à l’API

Avant d’utiliser le SDK Go OUTSCALE, vous devez le configurer afin qu’il puisse se connecter aux API OUTSCALE.

Vous devez spécifier :

  • Les identifiants utilisés pour authentifier vos requêtes.

  • L’endpoint d’API ou la Région vers lesquels les requêtes sont envoyées.

Vous pouvez également configurer des paramètres HTTP facultatifs, tels qu’un client HTTP personnalisé ou un délai d’expiration, selon vos besoins.

Authentification

Vous devez fournir des identifiants valides pour accéder à l’API OUTSCALE. Sans identifiants valides, les requêtes à l’API échouent.

Le SDK vous permet de vous authentifier à l’aide d’access keys :

  • Dans votre code (recommandé)

  • Dans les variables d’environnement

  • Dans le fichier de configuration

Les variables d’environnement sont prioritaires sur le fichier de configuration. Si des access keys sont définies dans les variables d’environnement, les valeurs définies dans le fichier de configuration seront écrasées.

Authentification à l’aide du code Go

Dans votre fichier Go, utilisez la syntaxe suivante :

cfg.SetAccessKey("YOUR_ACCESS_KEY")
cfg.SetSecretKey("YOUR_SECRETKEY")

Authentification à l’aide des variables d’environnement

Définissez votre access key et votre secret key dans les variables d’environnement à l’aide des commandes suivantes :

$ export OSC_ACCESS_KEY=xxx
$ export OSC_SECRET_KEY=yyy

Le SDK authentifie automatiquement les requêtes à l’aide des variables d’environnement OSC_ACCESS_KEY et OSC_SECRET_KEY.

Authentification à l’aide du fichier d’identifiants

Vous pouvez définir autant de profils que nécessaire dans le fichier ~/.osc/config.json, en utilisant la syntaxe suivante :

{
  "default": {
    "access_key": "<ACCESS_KEY>",
    "secret_key": "<SECRET_KEY>"
  },
  "profile_1": {
    "access_key": "<ACCESS_KEY>",
    "secret_key": "<SECRET_KEY>"
  },
  "profile_2": {
    "access_key": "<ACCESS_KEY>",
    "secret_key": "<SECRET_KEY>"
  }
}

Par défaut, le SDK utilise le profil default.

Pour utiliser un autre profil du même fichier d’identifiants, vous pouvez définir la variable d’environnement OSC_PROFILE avant d’exécuter votre application Go.

L’exemple suivant exécute l’application à l’aide du profil profile_1 :

$ export OSC_PROFILE=profile_1
$ go run main.go

Le SDK charge alors les identifiants associés à profile_1 au lieu de ceux du profil default.

Vous pouvez également sélectionner le profil directement dans votre code Go lors de la création du client, à l’aide de la syntaxe suivante :

config, err := osc.LoadDefaultConfig(
    context.TODO(),
    osc.WithProfile("profile_1"),
)
if err != nil {
    log.Fatal(err)
}

client := osc.NewFromConfig(config)

Cela vous permet de choisir le profil à utiliser sans modifier le fichier d’identifiants.

Endpoint et Région

Vous devez spécifier l’endpoint d’API ou la Région à utiliser.

L’exemple suivant configure l’endpoint pour la Région eu-west-2 :

cfg := osc.NewConfiguration()
cfg.SetHost("https://api.eu-west-2.outscale.com/api/v1")

Initialisation

Pour utiliser le SDK Go OUTSCALE, vous devez créer un client d’API à partir d’une configuration définie au préalable.

L’exemple suivant initialise un client d’API que vous pouvez utiliser pour accéder aux services générés :

cfg := osc.NewConfiguration()
client := osc.NewAPIClient(cfg)

Consultez GoDoc et le répertoire examples pour obtenir des méthodes d’authentification et modèles de configuration détaillés.

Après avoir créé le client d’API, vous pouvez effectuer votre premier appel API en utilisant la syntaxe suivante dans votre fichier :

package main

import (
    "fmt"
    osc "github.com/outscale/osc-sdk-go/v3"
)

func main() {
    cfg := osc.NewConfiguration()
    client := osc.NewAPIClient(cfg)

// Appel d'API : lecture des VM.
    resp, _, err := client.VmApi.ReadVms(nil)
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Println(resp)
}

Une fois initialisé, le client peut être utilisé pour interagir avec les services OUTSCALE.

Exemples

Le dépôt GitHub du SDK Go OUTSCALE inclut un répertoire examples/. Nous vous recommandons de partir de ces exemples et de les adapter à votre propre cas d’utilisation.

Lister les VM

L’exemple suivant montre comment récupérer et afficher la liste des machines virtuelles.

package examples_test

import (
	"testing"

	"github.com/outscale/osc-sdk-go/v3/pkg/osc"
	"github.com/stretchr/testify/require"
)

func TestReadVms(t *testing.T) {
	client := newOSCClient(t)

// 1. Récupère la liste des VM.
	read, err:= client.ReadVms(t.Context(), osc.ReadVmsRequest{Filters: nil})
// 2. Vérifie la collection de VM renvoyée.
	require.NoError(t, err)
	require.NotNil(t, read.Vms)
// 3. Enregistre l'ID et l'ID d'image de chaque VM dans les logs.
	for i, vm := range *read.Vms {
		t.Logf("[%d] Id: %s; ImageId: %s", i, vm.VmId, vm.ImageId)
	}
}

Gérer les keypairs

L’exemple suivant montre comment gérer les keypairs SSH, notamment comment les créer et les supprimer.

package examples_test

import (
	"testing"
	"time"

	"github.com/outscale/osc-sdk-go/v3/pkg/options"
	"github.com/outscale/osc-sdk-go/v3/pkg/osc"
	"github.com/stretchr/testify/require"
)

func TestKeypair(t *testing.T) {
	client := newOSCClient(t)

	ctx := t.Context()

	keypairName := "osc-sdk-go-test-" + RandomString(10)
	faux := false
// 1. Crée une keypair.
	resp, err := client.CreateKeypair(ctx, osc.CreateKeypairRequest{
		DryRun:      &faux,
		KeypairName: keypairName,
	}, options.WithRetryTimeout(time.Minute*10))
	require.NoError(t, err)

	deleted := false
	defer func() {
		if deleted {
			return
		}

		if resp.Keypair == nil || resp.Keypair.KeypairId == nil {
			return
		}

		_, _ = client.DeleteKeypair(ctx, osc.DeleteKeypairRequest{
			KeypairId: resp.Keypair.KeypairId,
		})
	}()
// 2. Vérifie les données de la keypair renvoyées par l'API.
	require.NotNil(t, resp.Keypair)
	require.NotNil(t, resp.Keypair.KeypairId)

	t.Logf("Keypair created: %s", *resp.Keypair.KeypairId)
// 3. Supprime la keypair.
	_, err = client.DeleteKeypair(ctx, osc.DeleteKeypairRequest{
		KeypairId: resp.Keypair.KeypairId,
	})
	require.NoError(t, err)
	deleted = true
}

Pages connexes

Exporter en PDF