Jak korzystać z biblioteki Vultr Go, aby uzyskać informacje o serwerze

• Wprowadzenie
• Wymagania wstępne
• Cele
• Krok 1: Tworzenie projektu
• Krok 2: Pobieranie biblioteki
• Krok 3: Zdobycie klucza API
• Krok 4: Tworzenie pliku programu
• Krok 5: Inicjalizacja klienta API
• Krok 6: Korzystanie z interfejsu API
• Krok 7: Wyświetlenie informacji
• Krok 8: Uruchomienie
• Wniosek

Wprowadzenie

Oficjalnej biblioteki Vultr Go można używać do interakcji z interfejsem API Vultr . Interfejs API Vultr pozwala kontrolować zasoby powiązane z kontem, w tym serwery, dns, zaporę ogniową, migawki, sieć i inne. Ten samouczek zawiera wprowadzenie do korzystania z oficjalnego klienta Go API, tworząc prostą aplikację do uzyskiwania informacji o serwerach.

Wymagania wstępne

• Komputer z systemem Windows, Linux lub macOS z zainstalowanym Go 1.12+.
• Podstawowa wiedza programistyczna.
• Opcjonalnie: IDE obsługujące Go (na przykład Visual Studio Code, emacs lub Atom).

Cele

• Aby dowiedzieć się, jak korzystać z oficjalnej biblioteki API Vultr.
• Aby napisać program do przeglądania informacji o serwerze.

Krok 1: Tworzenie projektu

Najpierw zaczniemy od utworzenia nowego modułu (projektu). Zwykle używasz adresu URL do repozytorium dla swojego kodu jako nazwy modułu, ale wykracza to poza zakres tego samouczka. Na razie użyjemy serverinfo jako nazwy modułu.

Aby utworzyć projekt, uruchom następujące polecenia:

# Create the folder in the current directory.
mkdir serverinfo

# Enter the new folder.
cd serverinfo

# Initialize the module.
go mod init serverinfo

Krok 2: Pobieranie biblioteki

Następnie pobierzemy bibliotekę API z GitHub (witryny hostującej kod). Aby pobrać biblioteki, musisz użyć go getpolecenia. Spowoduje to automatyczne pobranie biblioteki i jej zależności podczas dodawania jej do pliku go.mod . W tym samym terminalu, który otworzyłeś wcześniej, wprowadź następującą komendę:

go get github.com/vultr/govultr

Krok 3: Zdobycie klucza API

Aby korzystać z klienta API, potrzebujesz klucza API. Możesz pobrać swój klucz API z zakładki API sekcji Konto na pulpicie nawigacyjnym . Musisz także autoryzować swój adres IP, aby używać klucza API. Możesz znaleźć swój adres IP, przechodząc do ifconfig.me . Pamiętaj, że szukasz publicznego adresu IP, a nie prywatnego. Twój prywatny adres IP znajduje się w ustawieniach sieciowych na komputerze i należy do jednego z następujących zakresów CIDR: 10.0.0.0/8 , 172.16.0.0/12 lub 192.168.0.0/16 .

Po uzyskaniu adresu IP dodaj go w sekcji Kontrola dostępu . W polu po / wpisz 32. /32jest znaczeniem maski sieci 255.255.255.255. Oznacza to, że zakres obejmuje tylko twoje IP.

Ostrzeżenie: chroń swój klucz API tak, jakbyś chronił swoje hasło. Klucz API ma dostęp do całego konta, w tym rozliczeń, serwerów i pamięci.

Krok 4: Tworzenie pliku programu

Teraz zaczniemy pracować nad programem. Otwórz folder, który utworzyliśmy w wybranym przez siebie edytorze, i utwórz plik o nazwie main.go.

Wewnątrz pliku wpisz lub skopiuj i wklej następujący kod:

package main

import (
    "context"
    "fmt"
    "os"

    "github.com/vultr/govultr"
)

func main() {

}

package mainMówi Przejść że tworzymy polecenia, a nie biblioteki. Instrukcja importu określa zależności, których będziemy używać. func main()to funkcja wywoływana podczas uruchamiania naszego programu.

Krok 5: Inicjalizacja klienta API

Następnym krokiem jest zainicjowanie klienta API. Aby to zrobić, musimy użyć funkcji govultr.NewClient (http.Client, string) . Dodaj następujący kod do funkcji main () :

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

Zastąp YOURAPIKEYkluczem API pobranym wcześniej.

Przyjrzyjmy się temu kodowi nieco bliżej. Po lewej stronie :=mamy client. To jest nazwa zmiennej . Zmienna przechowuje wartości. Po prawej stronie mamy wywołanie funkcji do govultr.NewClient . Pierwszy parametr jest zerowy, ponieważ nie musimy zmieniać domyślnego klienta HTTP. Drugi parametr to klucz API, którego używamy do uwierzytelnienia się. :=Operator przydziela prawą stroną do lewej strony, w tym przypadku, wynik wywołania funkcji do client.

Krok 6: Korzystanie z interfejsu API

Nasz program wciąż nic nie robi. Aby było to przydatne, będziemy pobierać informacje o naszych serwerach od Vultr. Użyjemy funkcji govultr.Client.Server.List (context.Context) ([] govultr.Server, error) . Dodaj następujący kod na końcu funkcji main () :

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

W tym kodzie wywołujemy funkcję API w celu pobrania informacji o serwerze. Nie martw się jeszcze o znaczenie kontekstu , ponieważ jest to bardziej zaawansowany temat. Na razie musimy tylko wiedzieć, że kontekst kontroluje sposób działania klienta API. context.Background () zwraca pusty kontekst . Po pobraniu informacji o serwerze do dwóch zmiennych, serwerów i err , sprawdzamy, czy wystąpił błąd. Jeśli tak, informujemy użytkownika o błędzie i wychodzimy z kodem 1 (błąd).

Krok 7: Wyświetlenie informacji

Teraz, gdy mamy tablicę serwerów na serwerach zmiennej ( [] govultr.Server ), możemy rzeczywiście go wyświetlić. Dodaj następujący kod na końcu funkcji 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,
    )
}

Po pierwsze, możemy wydrukować (wyświetlacz) nagłówek, Servers:. Następnie zapętlamy tablicę serwerów , ignorując indeks, przypisując go do _i przypisując bieżący serwer do zmiennej serwera . Wewnątrz pętli wyświetlamy etykietę serwera, adres IP, lokalizację, oczekujące opłaty, bieżącą przepustowość i dozwoloną przepustowość. Aby to zrobić skutecznie, używamy ciągów formatu , które wyglądają jak " %s (%s) - %s - $%s pending charges - %.2f/%s GB bandwidth\n". Te %s środki zastąpił kolejny ciąg, podczas gdy %.2fśrodki do wydrukowania obok float (liczby dziesiętne) w zaokrągleniu do 2 miejsc po przecinku. Reszta ciągu formatu jest drukowana dosłownie (w stanie, w jakim się znajduje).

Krok 8: Uruchomienie

W tym momencie Twój kod powinien wyglądać następująco:

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,
        )
    }
}

Możemy teraz uruchomić kod. Wróć do terminalu, który otworzyliśmy wcześniej i wprowadź polecenie go run. Dane wyjściowe będą przypominać następujące:

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

Jeśli pojawi się błąd, upewnij się, że klucz API i adres IP są poprawne.

Wniosek

W tym momencie nauczysz się podstaw korzystania z oficjalnego klienta API i napisałeś program, który wyświetli informacje o serwerach na twoim koncie.

Dalsze kroki

Stąd możesz zrobić znacznie więcej. Na przykład możesz napisać program, który zapewni nowy serwer, gdy będzie mało pamięci. Możesz napisać aplikację, aby automatycznie uaktualnić serwer, gdy brakuje przepustowości lub miejsca. Możesz nawet napisać narzędzie do automatycznej aktualizacji rekordów DNS na podstawie bieżącego adresu IP.

Więcej informacji na temat biblioteki govultr można znaleźć w dokumentacji biblioteki govultr na temat godoc .

govultr to projekt typu open source . Jeśli znajdziesz jakieś błędy w govultr, możesz zgłosić je na GitHub . Możesz także przyczynić się bezpośrednio do kodu, przesyłając żądanie ściągnięcia .