Como usar a biblioteca Vultr Go para obter informações sobre o servidor

• Introdução
• Pré-requisitos
• Metas
• Etapa 1: Criando o Projeto
• Etapa 2: baixando a biblioteca
• Etapa 3: obtendo sua chave de API
• Etapa 4: Criando o Arquivo do Programa
• Etapa 5: inicializando o cliente da API
• Etapa 6: usando a API
• Etapa 7: Mostrando as informações
• Etapa 8: executando
• Conclusão

Introdução

A biblioteca oficial do Vultr Go pode ser usada para interagir com a API do Vultr . A API do Vultr permite controlar os recursos associados à sua conta, incluindo servidores, DNS, firewall, instantâneos, rede e muito mais. Este tutorial fornece uma introdução ao uso do cliente oficial da API Go, criando um aplicativo simples para obter informações sobre seus servidores.

Pré-requisitos

• Um computador executando o Windows, Linux ou macOS com o Go 1.12+ instalado.
• Conhecimento básico de programação.
• Opcional: Um IDE que suporte o Go (por exemplo, Visual Studio Code, emacs ou Atom).

Metas

• Para aprender a usar a biblioteca oficial da API Vultr.
• Para escrever um programa para visualizar informações do servidor.

Etapa 1: Criando o Projeto

Primeiro, começaremos criando um novo módulo (projeto). Normalmente, você usaria a URL para um repositório para o seu código como o nome do módulo, mas isso está além do escopo deste tutorial. Por enquanto, usaremos serverinfo como o nome do módulo.

Para criar o projeto, execute os seguintes comandos:

# Create the folder in the current directory.
mkdir serverinfo

# Enter the new folder.
cd serverinfo

# Initialize the module.
go mod init serverinfo

Etapa 2: baixando a biblioteca

Em seguida, faremos o download da biblioteca da API no GitHub (um site de hospedagem de código). Para baixar bibliotecas, você precisa usar o go getcomando Isso fará o download automático da biblioteca e de suas dependências, enquanto a adiciona ao arquivo go.mod . No mesmo terminal que você abriu anteriormente, digite o seguinte comando:

go get github.com/vultr/govultr

Etapa 3: obtendo sua chave de API

Para usar o cliente da API, você precisará da sua chave de API. Você pode recuperar sua chave de API na guia API da seção Conta do seu Painel . Você também precisará autorizar seu endereço IP para usar a chave da API. Você pode encontrar seu endereço IP em ifconfig.me . Observe que você está procurando seu IP público , não o seu IP privado. Seu IP privado é o que você encontraria nas configurações de rede do seu computador e está em um dos seguintes intervalos de CIDR: 10.0.0.0/8 , 172.16.0.0/12 ou 192.168.0.0/16 .

Depois de obter seu endereço IP, adicione-o na seção Controle de acesso . Na caixa após o / , digite 32. /32é um significado de máscara de rede 255.255.255.255. Isso significa que apenas o seu IP está incluído no intervalo.

Aviso: proteja sua chave de API como se protegesse sua senha. A chave da API tem acesso a toda a sua conta, incluindo cobrança, servidores e armazenamento.

Etapa 4: Criando o Arquivo do Programa

Agora, vamos começar a trabalhar no programa. Abra a pasta que criamos na sua escolha de editor e crie um arquivo chamado main.go.

Dentro do arquivo, digite ou copie e cole o seguinte código:

package main

import (
    "context"
    "fmt"
    "os"

    "github.com/vultr/govultr"
)

func main() {

}

O package mainTell diz que estamos criando um comando, não uma biblioteca. A declaração de importação declara as dependências que usaremos. func main()é a função chamada quando executamos nosso programa.

Etapa 5: inicializando o cliente da API

A próxima etapa é inicializar o cliente da API. Para fazer isso, precisamos usar a função govultr.NewClient (http.Client, string) . Adicione o seguinte código dentro da função main () :

client := govultr.NewClient(nil, "YOURAPIKEY")

Substitua YOURAPIKEYpela chave da API que você recuperou anteriormente.

Vejamos esse código um pouco mais de perto. No lado esquerdo do :=, temos client. Esse é o nome de uma variável . Uma variável armazena valores. No lado direito, temos uma chamada de função para govultr.NewClient . O primeiro parâmetro é nulo, porque não precisamos alterar o cliente HTTP padrão. O segundo parâmetro é a chave da API que estamos usando para nos autenticarmos. O :=operador atribui o lado direito ao lado esquerdo, neste caso, o resultado da chamada de função para client.

Etapa 6: usando a API

Nosso programa ainda não faz nada ainda. Para torná-lo útil, vamos recuperar informações sobre nossos servidores do Vultr. Usaremos a função govultr.Client.Server.List (context.Context) ([] govultr.Server, erro) . Adicione o seguinte código no final da função main () :

servers, err := client.Server.List(context.Background())
if err != nil {
    fmt.Fprintf(os.Stderr, "Error: %v\n", err)
    os.Exit(1)
}

Neste código, estamos chamando a função API para recuperar as informações do servidor. Não se preocupe com o significado do contexto ainda, pois esse é um tópico mais avançado. Por enquanto, tudo o que precisamos saber é que o contexto controla como o cliente da API é executado. context.Background () retorna um contexto vazio . Depois de recuperar as informações do servidor nas duas variáveis server e err , verificamos se houve algum erro. Nesse caso, informamos ao usuário o erro e saímos com o código 1 (erro).

Etapa 7: Mostrando as informações

Agora que temos uma matriz de servidores na variável servers ( [] govultr.Server ), podemos realmente exibi-la. Adicione o seguinte código no final da função main () :

fmt.Println("Servers:")
for _, server := range servers {
    fmt.Printf("  %s (%s) - %s - $%s pending charges - %.2f/%s GB bandwidth\n",
        server.Label,
        server.MainIP,
        server.Location,
        server.PendingCharges,
        server.CurrentBandwidth,
        server.AllowedBandwidth,
    )
}

Primeiro, imprimimos (exibimos) um cabeçalho Servers:,. Em seguida, fazemos um loop na matriz de servidores , ignorando o índice atribuindo-o _e atribuindo o servidor atual à variável de servidor . Dentro do loop, exibimos o rótulo do servidor, o endereço IP, o local, as cobranças pendentes, a largura de banda atual e a largura de banda permitida. Para fazer isso com eficiência, usamos strings de formato , a string que se parece " %s (%s) - %s - $%s pending charges - %.2f/%s GB bandwidth\n". Os %s meios para substituir a próxima string, enquanto os %.2fmeios para imprimir o próximo float (número decimal) arredondado para 2 casas decimais. O restante da string de formato é impresso literalmente (como está).

Etapa 8: executando

Neste ponto, seu código deve se parecer com o seguinte:

package main

import (
    "context"
    "fmt"
    "os"

    "github.com/vultr/govultr"
)

func main() {
    client := govultr.NewClient(nil, "YOURAPIKEY")

    servers, err := client.Server.List(context.Background())
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error: %v\n", err)
        os.Exit(1)
    }

    fmt.Println("Servers:")
    for _, server := range servers {
        fmt.Printf("  %s (%s) - %s - $%s pending charges - %.2f/%s GB bandwidth\n",
            server.Label,
            server.MainIP,
            server.Location,
            server.PendingCharges,
            server.CurrentBandwidth,
            server.AllowedBandwidth,
        )
    }
}

Agora podemos executar o código. Voltar à que o terminal abriu no início e digite o comando go run. A saída será semelhante ao seguinte:

Servers:
  server1 (198.51.100.4) - New Jersey - $3.70 pending charges - 17.64/1000 GB bandwidth
  server2 (198.51.100.9) - Toronto - $1.70 pending charges - 3.24/500 GB bandwidth

Se você receber um erro, verifique se a chave da API e o endereço IP estão corretos.

Conclusão

Neste ponto, você terá aprendido com êxito o básico sobre como usar o cliente oficial da API e gravado um programa que exibirá informações sobre os servidores em sua conta.

Passos adicionais

A partir daqui, você pode fazer muito mais. Por exemplo, você pode escrever um programa para provisionar um novo servidor quando estiver com pouca memória. Você pode escrever um aplicativo para atualizar automaticamente o servidor quando estiver com pouca largura de banda ou armazenamento. Você pode até escrever uma ferramenta para atualizar automaticamente os registros DNS com base no seu IP atual.

Para mais informações sobre a biblioteca govultr, você pode encontrar a documentação da biblioteca govultr em godoc .

O govultr é um projeto de código aberto . Se você encontrar algum erro no govultr, poderá denunciá-lo no GitHub . Você também pode contribuir diretamente com o código enviando uma solicitação de recebimento .