Azion Go SDK

The Azion SDK for Go facilitates the use of the Azion API services by providing a set of tools that make the development of Go applications smoother.


For using the Go SDK, you need to:

  • Have Go 1.17 or later installed.
  • Have a go project with a main.go file created.
  • Initialize a Go module with go mod init <name>.

Downloading and installing Azion SDK

Section titled Downloading and installing Azion SDK

The Azion API Go SDK is available on GitHub.

  • On your go project’s root directory, open the terminal and run:
Terminal window
go get github.com/aziontech/azionapi-go-sdk

Or simply:

Terminal window
go mod tidy

This is a complete practical example that can be copied and pasted to your main.go file.

After that, you need to run the project with:

Terminal window
go run main.go

Creating an Intelligent DNS zone

Section titled Creating an Intelligent DNS zone
package main
import (
"bufio"
"context"
"fmt"
"io"
"net/http"
"os"
"strings"
sdk "github.com/aziontech/azionapi-go-sdk/idns"
)
const (
intelligentDnsURL = "https://api.azionapi.net/"
)
type Client struct {
apiClient sdk.APIClient
}
func main() {
var personalToken string
fmt.Println("Hey, there! Welcome to iDNS example")
fmt.Println("Please, provide your Personal Token: ")
fmt.Scanf("%s", &personalToken)
err := IDNSHandler(personalToken)
if err != nil {
fmt.Println(err)
}
}
// IDNSHandler
//
// - I/O operations - asks and reads domain name e zone
// - Instantiates a new client
// - Calls NewIdns
func IDNSHandler(personalToken string) error {
var domainName, dnsZone string
active := true
reader := bufio.NewReader(os.Stdin)
fmt.Println("Plase, provide the Domain Name: ")
domainName, err := reader.ReadString('\n')
if err != nil {
return err
}
domainName = strings.Replace(domainName, "\n", "", -1)
fmt.Println("Enter a dns zone: ")
dnsZone, err = reader.ReadString('\n')
if err != nil {
return err
}
dnsZone = strings.Replace(dnsZone, "\n", "", -1)
var f *http.Client
client := NewClient(f, intelligentDnsURL, personalToken)
err = client.NewIdns(&domainName, &dnsZone, &active)
if err != nil {
fmt.Println(err)
return err
}
return nil
}
// NewIdns
// - Instantiate a sdk.Zone object
// - Instantiate the request and exec it
// - Prints success or error
func (c *Client) NewIdns(domainName, domain *string, active *bool) error {
ctx := context.Background()
idns := new(sdk.Zone)
idns.Name = domainName
idns.Domain = domain
idns.IsActive = active
fmt.Println("Creating iDNS zone....")
req := c.apiClient.ZonesApi.PostZone(ctx).Zone(*idns)
_, httpResp, err := req.Execute()
if err != nil {
fmt.Println(httpResp)
return err
}
bytes, err := io.ReadAll(httpResp.Body)
if err != nil {
return err
}
fmt.Println(string(bytes))
return nil
}
// NewClient
// - Instantiates a new skd-api client
// - Set headers
func NewClient(f *http.Client, url string, token string) *Client {
conf := sdk.NewConfiguration()
conf.HTTPClient = f
conf.AddDefaultHeader("Authorization", "token "+token)
conf.AddDefaultHeader("Accept", "application/json;version=3")
conf.Servers = sdk.ServerConfigurations{
{URL: url},
}
return &Client{
apiClient: *sdk.NewAPIClient(conf),
}
}

Learn about the implementation of the Azion API SDK by analyzing the steps of the creation of a new Intelligent DNS zone.

The Go client abstracts away the complexity of the underlying service or API, making it easier for developers to integrate with it.

To instantiate a client, you have to:

  1. Import the package you want to use. In this example, you’ll create a new Intelligent DNS zone.
import(
sdk "github.com/aziontech/azionapi-go-sdk/idns"
)
  1. Instantiate the client:
// Client is used to instantiate a Azion API Client
type Client struct {
apiClient sdk.APIClient
}
// NewClient
// - Receives:
// A *http.Client
// The base path to the API you want to consume. ex: https://api.azionapi.net/
// The Azion Personal Token
func NewClient(f * http.Client, url string, token string) * Client {
conf: = sdk.NewConfiguration()
conf.HTTPClient = f
conf.AddDefaultHeader("Authorization", "token " + token)
conf.AddDefaultHeader("Accept", "application/json;version=3")
conf.Servers = sdk.ServerConfigurations {
{
URL: url
},
}
// Returns a ready to use client
return &Client {
apiClient: * sdk.NewAPIClient(conf),
}
}

Creating an Intelligent DNS zone

Section titled Creating an Intelligent DNS zone

Take a look at the creation of an Intelligent DNS zone using the SDK:

// NewIdns
// - Instantiate a sdk.Zone object
// - Instantiate the request and exec it
func(c * Client) NewIdns(domainName, domain * string, active * bool) error {
// Instantiate a ctx variable
ctx: = context.Background()
// From the section iDNS of the SDK, we initialize a sdk.Zone object
// Informing the required values for creating an iDNS zone.
idns: = new(sdk.Zone)
idns.Name = domainName
idns.Domain = domain
idns.IsActive = active
// Make use of the PostZone Method, passing the idns zone object
req: = c.apiClient.ZonesApi.PostZone(ctx).Zone( * idns)
res,
httpResp,
err: = req.Execute()
if err != nil {
return err
}
// Here, the logic related to the response is applied...
fmt.Println(res, httpResp)
return nil
}

The Azion SDK offers management to the following services:


Contributors