Hur man använder Vultr Go-biblioteket för att få serverinformation

• Introduktion
• Förutsättningar
• Mål
• Steg 1: Skapa projektet
• Steg 2: Ladda ner biblioteket
• Steg 3: Hämta din API-nyckel
• Steg 4: Skapa programfilen
• Steg 5: Initiera API-klienten
• Steg 6: Använda API
• Steg 7: Visar informationen
• Steg 8: Löpning
• Slutsats

Introduktion

Det officiella Vultr Go-biblioteket kan användas för att interagera med Vultr API . Vultr API låter dig kontrollera resurserna som är kopplade till ditt konto, inklusive servrar, dns, brandvägg, ögonblicksbilder, nätverk och mer. Denna handledning kommer att ge en introduktion till att använda den officiella Go API-klienten genom att skapa en enkel applikation för att få information om dina servrar.

Förutsättningar

• En dator som kör Windows, Linux eller macOS med Go 1.12+ installerat.
• Grundläggande programmeringskunskaper.
• Valfritt: En IDE som stöder Go (till exempel Visual Studio Code, emacs eller Atom).

Mål

• För att lära dig hur du använder det officiella Vultr API-biblioteket.
• Att skriva ett program för att se serverinformation.

Steg 1: Skapa projektet

Först börjar vi med att skapa en ny modul (projekt). Vanligtvis skulle du använda URL:en till ett arkiv för din kod som modulnamn, men det ligger utanför den här handledningen. För närvarande kommer vi att använda serverinfo som modulnamn .

För att skapa projektet, kör följande kommandon:

# Create the folder in the current directory. mkdir serverinfo # Enter the new folder. cd serverinfo # Initialize the module. go mod init serverinfo

Steg 2: Ladda ner biblioteket

Därefter kommer vi att ladda ner API-biblioteket från GitHub (en kodvärdwebbplats). För att ladda ner bibliotek måste du använda go getkommandot. Detta kommer automatiskt att ladda ner biblioteket och dess beroenden samtidigt som det läggs till i go.mod- filen. I samma terminal som du öppnade tidigare, skriv in följande kommando:

go get github.com/vultr/govultr

Steg 3: Hämta din API-nyckel

För att använda API-klienten behöver du din API-nyckel. Du kan hämta din API-nyckel från API- fliken i avsnittet Konto på din Dashboard . Du måste också auktorisera din IP-adress för att använda API-nyckeln. Du kan hitta din IP-adress genom att gå till ifconfig.me . Observera att du letar efter din offentliga IP, inte din privata. Din privata IP är vad du skulle hitta i dina nätverksinställningar på din dator, och är inom ett av följande CIDR-intervall: 10.0.0.0/8 , 172.16.0.0/12 eller 192.168.0.0/16 .

När du har din IP-adress, lägga den under Access Control avsnittet. I rutan efter / skriver du 32. /32är en nätmask betydelse 255.255.255.255. Det betyder att endast din IP ingår i sortimentet.

Varning: Skydda din API-nyckel som du skulle skydda ditt lösenord. API-nyckeln har åtkomst till hela ditt konto, inklusive fakturering, servrar och lagring.

Steg 4: Skapa programfilen

Nu ska vi börja arbeta med programmet. Öppna mappen vi skapade i ditt val av redigerare och skapa en fil med namnet main.go.

Inuti filen, skriv eller kopiera och klistra in följande kod:

package main import ( "context" "fmt" "os" "github.com/vultr/govultr" ) func main() { }

Den package mainsäger till Go att vi skapar ett kommando, inte ett bibliotek. Importsatsen deklarerar de beroenden vi kommer att använda. func main()kallas funktionen när vi kör vårt program.

Steg 5: Initiera API-klienten

Nästa steg är att initiera API-klienten. För att göra detta måste vi använda funktionen govultr.NewClient(http.Client, string) . Lägg till följande kod i main()- funktionen:

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

Ersätt YOURAPIKEYmed API-nyckeln du hämtade tidigare.

Låt oss titta på den här koden lite närmare. På vänster sida av :=, har vi client. Det är namnet på en variabel . En variabel lagrar värden. På höger sida har vi ett funktionsanrop till govultr.NewClient . Den första parametern är noll, eftersom vi inte behöver ändra standard HTTP-klienten. Den andra parametern är API-nyckeln vi använder för att autentisera oss. Den :=operatör tilldelar den högra sidan till den vänstra sidan, i detta fall, resultatet av funktionsanrop till client.

Steg 6: Använda API

Vårt program gör fortfarande ingenting. För att göra det användbart kommer vi att hämta information om våra servrar från Vultr. Vi kommer att använda funktionen govultr.Client.Server.List(context.Context) ([]govultr.Server, error) . Lägg till följande kod i slutet av main()- funktionen:

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

I den här koden anropar vi API-funktionen för att hämta serverinformationen. Oroa dig inte för innebörden av sammanhanget ännu, eftersom det är ett mer avancerat ämne. För nu är allt vi behöver veta att sammanhanget styr hur API-klienten körs. context.Background() returnerar en tom kontext . Efter att vi har hämtat serverinformationen till de två variablerna, servrar och err , kontrollerar vi om det var ett fel. Om så är fallet, informerar vi användaren om felet och avslutar med kod 1 (fel).

Steg 7: Visar informationen

Nu när vi har en uppsättning servrar i servervariabeln ( []govultr.Server ), kan vi faktiskt visa den. Lägg till följande kod i slutet av main()- funktionen:

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

Först skriver vi ut (visar) en rubrik, Servers:. Sedan vi slinga över servrar array, ignorera index koppla den till _och tilldela den aktuella servern till servern variabeln. Inne i slingan visar vi serverns etikett, IP-adress, plats, utestående avgifter, aktuell bandbredd och tillåten bandbredd. För att göra detta effektivt använder vi formatsträngar , strängen som ser ut som " %s (%s) - %s - $%s pending charges - %.2f/%s GB bandwidth\n". De %smedel för att ersätta nästa sträng, medan %.2fmedel för att skriva ut nästa flottör (decimaltal) avrundat till 2 decimaler. Resten av formatsträngen skrivs ut bokstavligen (i befintligt skick).

Steg 8: Löpning

Vid det här laget bör din kod se ut så här:

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

Vi kan nu köra koden. Gå tillbaka till terminalen vi öppnade tidigare och ange kommandot go run. Utgången kommer att likna följande:

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

Om du får ett fel, se till att din API-nyckel och IP-adress är korrekta.

Slutsats

Vid det här laget har du framgångsrikt lärt dig grunderna i hur du använder den officiella API-klienten och skrivit ett program som visar information om servrarna på ditt konto.

Ytterligare steg

Härifrån kan du göra mycket mer. Du kan till exempel skriva ett program för att tillhandahålla en ny server när du har ont om minne. Du kan skriva en app för att automatiskt uppgradera din server när du har ont om bandbredd eller lagringsutrymme. Du kan till och med skriva ett verktyg för att automatiskt uppdatera DNS-poster baserat på din nuvarande IP.

För mer information om govultr-biblioteket kan du hitta govultr-bibliotekets dokumentation på godoc .

govultr är ett projekt med öppen källkod . Om du hittar några buggar i govultr kan du rapportera dem på GitHub . Du kan också bidra till koden direkt genom att skicka in en pull-förfrågan .