Snabbstart: Använda Go-språk för att ansluta och fråga efter data i Azure Database for PostgreSQL flexibel server

Den här snabbstarten visar hur du ansluter till en Azure Database för PostgreSQL med hjälp av kod som skrivits i språket Go (golang). Den visar hur du använder SQL-instruktioner för att fråga, infoga, uppdatera och ta bort data i databasen. Den här artikeln förutsätter att du är bekant med utveckling med Go, men att du är nybörjare på att arbeta med Azure Database for PostgreSQL.

Förutsättningar

Den här snabbstarten använder de resurser som skapats i Skapa en Azure Database for PostgreSQL som utgångspunkt.

Viktigt!

Använd en server med offentlig åtkomst (tillåtna IP-adresser) aktiverad för den här snabbstarten. Att använda en server med privat åtkomst (VNet-integrering) aktiverad för att slutföra den här snabbstarten kan innebära extra steg som inte omfattas.

Se till att IP-adressen som du ansluter från läggs till i serverns brandväggsregler med hjälp av Azure-portalen eller Azure CLI.

Installera Go och pq connector

Installera Go och Pure Go Postgres-drivrutinen (pq) på din egen dator. Följ instruktionerna för din plattform:

Ladda ned och installera Go för Microsoft Windows enligt installationsanvisningarna.
Starta kommandotolken från Start-menyn.
Skapa en mapp för projektet, till exempel mkdir %USERPROFILE%\go\src\postgresqlgo.
Ändra katalogen till projektmappen, till exempel cd %USERPROFILE%\go\src\postgresqlgo.
Ange miljövariabeln för GOPATH så att den hänvisar till källkodskatalogen. set GOPATH=%USERPROFILE%\go.
Kör kör mod init för att skapa en modul i den aktuella katalogen. Till exempel: go mod init postgresqlgo.
- Parametern <module_path> är vanligtvis en plats i en GitHub-lagringsplats , till exempel github.com/<your_github_account_name>/<directory>.
- När du skapar en kommandoradsapp som ett test och inte publicerar appen <module_path> behöver den inte referera till en faktisk plats. Till exempel postgresqlgo.
Installera Pure Go Postgres-drivrutinen (pq) genom att köra go get github.com/lib/pq kommandot.

Sammanfattningsvis ska du installera Go och sedan köra dessa kommandon i kommandotolken:
```
mkdir  %USERPROFILE%\go\src\postgresqlgo
cd %USERPROFILE%\go\src\postgresqlgo
set GOPATH=%USERPROFILE%\go
go mod init postgresqlgo
go get github.com/lib/pq
```

Starta Bash-gränssnittet.
Installera Go genom att köra sudo apt-get install golang-go.
Skapa en mapp för projektet i hemkatalogen, till exempel mkdir -p ~/go/src/postgresqlgo/.
’Ändra katalogen till mappen, till exempel cd ~/go/src/postgresqlgo/.
Ange miljövariabeln så att den GOPATH pekar på en giltig källkatalog, till exempel den aktuella hemkatalogens Go-mapp. I Bash-gränssnittet kör du export GOPATH=~/go för att lägga till Go-katalogen som GOPATH för den aktuella shell-sessionen.
Kör kör mod init för att skapa en modul i den aktuella katalogen. Till exempel: go mod init postgresqlgo.
- Parametern <module_path> är vanligtvis en plats i en GitHub-lagringsplats , till exempel github.com/<your_github_account_name>/<directory>.
- När du skapar en kommandoradsapp som ett test och inte publicerar appen <module_path> behöver den inte referera till en faktisk plats. Till exempel postgresqlgo.

Installera Pure Go Postgres-drivrutinen (pq) genom att köra go get github.com/lib/pq kommandot.

Sammanfattningsvis ska du köra dessa bash-kommandon:

sudo apt-get install golang-go
mkdir -p ~/go/src/postgresqlgo/
cd ~/go/src/postgresqlgo/
export GOPATH=~/go/
go mod init postgresqlgo
go get github.com/lib/pq

Ladda ned och installera Go enligt installationsanvisningarna som matchar din plattform.
Starta Bash-gränssnittet.
Skapa en mapp för projektet i hemkatalogen, till exempel mkdir -p ~/go/src/postgresqlgo/.
’Ändra katalogen till mappen, till exempel cd ~/go/src/postgresqlgo/.
Ange miljövariabeln så att den GOPATH pekar på en giltig källkatalog, till exempel den aktuella hemkatalogens Go-mapp. I Bash-gränssnittet kör du export GOPATH=~/go för att lägga till Go-katalogen som GOPATH för den aktuella shell-sessionen.
Kör kör mod init för att skapa en modul i den aktuella katalogen. Till exempel: go mod init postgresqlgo.
- Parametern <module_path> är vanligtvis en plats i en GitHub-lagringsplats , till exempel github.com/<your_github_account_name>/<directory>.
- När du skapar en kommandoradsapp som ett test och inte publicerar appen <module_path> behöver den inte referera till en faktisk plats. Till exempel postgresqlgo.
Installera Pure Go Postgres-drivrutinen (pq) genom att köra go get github.com/lib/pq kommandot.

Sammanfattningsvis installerar du Go och kör sedan följande Bash-kommandon:
```
mkdir -p ~/go/src/postgresqlgo/
cd ~/go/src/postgresqlgo/
export GOPATH=~/go/
go mod init postgresqlgo
go get github.com/lib/pq
```

Hämta anslutningsinformation

Hämta den information som du behöver för att ansluta till Azure Database för PostgreSQL. Du behöver det fullständigt kvalificerade servernamnet och autentiseringsuppgifterna.

Logga in på Azure-portalen.
På den vänstra menyn i Azure-portalen väljer du Alla resurser och söker sedan efter den server som du skapade (till exempel mydemoserver).
Välj servernamnet.
På serverpanelen Översikt antecknar du Servernamn och Inloggningsnamn för serveradministratören. Om du glömmer lösenordet kan du även återställa det på den här panelen.

Skapa och köra Go-kod

Om du vill skriva Go-kod använder du en oformaterad textredigerare, till exempel Anteckningar i Microsoft Windows, Nano i Ubuntu eller TextEdit i macOS. Om du föredrar en rikare interaktiv utvecklingsmiljö (IDE) kan du prova GoLand by JetBrains, Visual Studio Code efter Microsoft eller Atom.
Klistra in Go-koden från följande avsnitt i textfiler och spara dem i projektmappen med filnamnstillägget *.go, till exempel Windows sökväg %USERPROFILE%\go\src\postgresqlgo\createtable.go eller Linux-sökväg ~/go/src/postgresqlgo/createtable.go.
Leta upp konstanterna HOST, DATABASE, USER och PASSWORD i koden och ersätt exempelvärdena med dina egna värden. När du skapar din Azure Database for PostgreSQL-server skapar du en databas med namnet postgres. Du kan använda den databasen eller en annan som du skapar.
Starta kommandotolken eller bash-gränssnittet. Ändra katalog till din projektmapp. På Windows använder du cd %USERPROFILE%\go\src\postgresqlgo\till exempel . I Linux använder du cd ~/go/src/postgresqlgo/. Några av de IDE-miljöer som nämns erbjuder funktioner för felsökning och körning utan att kräva shell-kommandon.
Kör koden genom att skriva kommandot go run createtable.go för att kompilera programmet och köra det.
Du kan också skapa koden i ett internt program genom att använda go build createtable.go. createtable.exe Starta sedan för att köra programmet.

Ansluta och skapa en tabell

Använd följande kod för att ansluta och skapa en tabell med sql-instruktionen CREATE TABLE följt av INSERT INTO SQL-uttryck för att lägga till rader i tabellen.

Koden importerar tre paket: sql-paketet, pq-paketet (som en drivrutin för att kommunicera med PostgreSQL-servern) och fmt-paketet för skrivna indata och utdata på kommandoraden.

Koden anropar metoden sql.Open() för att ansluta till databasen Azure Database for PostgreSQL och kontrollerar anslutningen genom att använda metoden db.Ping(). En databasreferens som håller anslutningspoolen för databasservern används genomgående. I koden anropas metoden Exec() flera gånger för att köra flera SQL-kommandon. Varje gång en anpassad checkError()-metod kontrollerar om ett fel uppstod och får panik för att avsluta om ett fel inträffar.

Ersätt parametrarna HOST, DATABASE, USER och PASSWORD med egna värden.

package main

import (
	"database/sql"
	"fmt"
	_ "github.com/lib/pq"
)

const (
	// Initialize connection constants.
	HOST     = "mydemoserver.postgres.database.azure.com"
	DATABASE = "postgres"
	USER     = "mylogin"
	PASSWORD = "<server_admin_password>"
)

func checkError(err error) {
	if err != nil {
		panic(err)
	}
}

func main() {
	// Initialize connection string.
	var connectionString string = fmt.Sprintf("host=%s user=%s password=%s dbname=%s sslmode=require", HOST, USER, PASSWORD, DATABASE)

	// Initialize connection object.
	db, err := sql.Open("postgres", connectionString)
	checkError(err)

	err = db.Ping()
	checkError(err)
	fmt.Println("Successfully created connection to database")

	// Drop previous table of same name if one exists.
	_, err = db.Exec("DROP TABLE IF EXISTS inventory;")
	checkError(err)
	fmt.Println("Finished dropping table (if existed)")

	// Create table.
	_, err = db.Exec("CREATE TABLE inventory (id serial PRIMARY KEY, name VARCHAR(50), quantity INTEGER);")
	checkError(err)
	fmt.Println("Finished creating table")

	// Insert some data into table.
	sql_statement := "INSERT INTO inventory (name, quantity) VALUES ($1, $2);"
	_, err = db.Exec(sql_statement, "banana", 150)
	checkError(err)
	_, err = db.Exec(sql_statement, "orange", 154)
	checkError(err)
	_, err = db.Exec(sql_statement, "apple", 100)
	checkError(err)
	fmt.Println("Inserted 3 rows of data")
}

Läs data

Använd följande kod för att ansluta och läsa data med en SELECT-SQL-instruktion.

Koden importerar tre paket: sql-paketet, pq-paketet (som en drivrutin för att kommunicera med PostgreSQL-servern) och fmt-paketet för skrivna indata och utdata på kommandoraden.

Koden anropar metoden sql.Open() för att ansluta till Azure Database for PostgreSQL-databasen och kontrollerar anslutningen genom att använda metoden db.Ping(). En databasreferens som håller anslutningspoolen för databasservern används genomgående. Den valda frågan körs genom att anropa metoden db. Query(), och de resulterande raderna sparas i en variabel av typen rader. Koden läser kolumndatavärdena i den aktuella raden med hjälp av metoden rows.Scan() och itererar över raderna med hjälp av iteratorn rows.Next() tills det inte finns fler rader. Varje rads kolumnvärden skrivs ut till konsolen. Varje gång används en anpassad checkError()-metod för att kontrollera om ett fel har uppstått och anropa panic för att avsluta om så är fallet.

Ersätt parametrarna HOST, DATABASE, USER och PASSWORD med egna värden.

package main

import (
	"database/sql"
	"fmt"
	_ "github.com/lib/pq"
)

const (
	// Initialize connection constants.
	HOST     = "mydemoserver.postgres.database.azure.com"
	DATABASE = "postgres"
	USER     = "mylogin"
	PASSWORD = "<server_admin_password>"
)

func checkError(err error) {
	if err != nil {
		panic(err)
	}
}

func main() {

	// Initialize connection string.
	var connectionString string = fmt.Sprintf("host=%s user=%s password=%s dbname=%s sslmode=require", HOST, USER, PASSWORD, DATABASE)

	// Initialize connection object.
	db, err := sql.Open("postgres", connectionString)
	checkError(err)

	err = db.Ping()
	checkError(err)
	fmt.Println("Successfully created connection to database")

	// Read rows from table.
	var id int
	var name string
	var quantity int

	sql_statement := "SELECT * from inventory;"
	rows, err := db.Query(sql_statement)
	checkError(err)
	defer rows.Close()

	for rows.Next() {
		switch err := rows.Scan(&id, &name, &quantity); err {
		case sql.ErrNoRows:
			fmt.Println("No rows were returned")
		case nil:
			fmt.Printf("Data row = (%d, %s, %d)\n", id, name, quantity)
		default:
			checkError(err)
		}
	}
}

Uppdatera datainformation

Använd följande kod för att ansluta och uppdatera data med en UPDATE-SQL-instruktion.

Koden importerar tre paket: sql-paketet, pq-paketet (som en drivrutin för att kommunicera med Postgres-servern) och fmt-paketet för skrivna indata och utdata på kommandoraden.

Koden anropar metoden sql. Öppna() för att ansluta till Azure Database for PostgreSQL databas och kontrollerar anslutningen med hjälp av metoden db. Ping(). En databasreferens som håller anslutningspoolen för databasservern används genomgående. Koden anropar metoden Exec() för att köra SQL-instruktionen som uppdaterar tabellen. En anpassad checkError()-metod används för att kontrollera om ett fel har uppstått och avslutas med panik om ett fel inträffar.

Ersätt parametrarna HOST, DATABASE, USER och PASSWORD med egna värden.

package main

import (
  "database/sql"
  _ "github.com/lib/pq"
  "fmt"
)

const (
	// Initialize connection constants.
	HOST     = "mydemoserver.postgres.database.azure.com"
	DATABASE = "postgres"
	USER     = "mylogin"
	PASSWORD = "<server_admin_password>"
)

func checkError(err error) {
	if err != nil {
		panic(err)
	}
}

func main() {

	// Initialize connection string.
	var connectionString string = 
		fmt.Sprintf("host=%s user=%s password=%s dbname=%s sslmode=require", HOST, USER, PASSWORD, DATABASE)

	// Initialize connection object.
	db, err := sql.Open("postgres", connectionString)
	checkError(err)

	err = db.Ping()
	checkError(err)
	fmt.Println("Successfully created connection to database")

	// Modify some data in table.
	sql_statement := "UPDATE inventory SET quantity = $2 WHERE name = $1;"
	_, err = db.Exec(sql_statement, "banana", 200)
	checkError(err)
	fmt.Println("Updated 1 row of data")
}

Ta bort data

Använd följande kod för att ansluta till databasen och ta bort data med hjälp av en DELETE SQL-instruktion .

Koden importerar tre paket: sql-paketet, pq-paketet (som en drivrutin för att kommunicera med Postgres-servern) och fmt-paketet för skrivna indata och utdata på kommandoraden.

Koden anropar metoden sql. Öppna() för att ansluta till Azure Database for PostgreSQL och kontrollerar anslutningen med hjälp av metoden db. Ping(). Ett databashandtag hanterar anslutningspoolen för databasservern och används genomgående. Koden anropar metoden Exec() för att köra SQL-instruktionen som tar bort en rad från tabellen. En anpassad checkError() metod kontrollerar om ett fel har inträffat och avslutas om ett fel inträffar.

Ersätt parametrarna HOST, DATABASE, USER och PASSWORD med egna värden.

package main

import (
  "database/sql"
  _ "github.com/lib/pq"
  "fmt"
)

const (
	// Initialize connection constants.
	HOST     = "mydemoserver.postgres.database.azure.com"
	DATABASE = "postgres"
	USER     = "mylogin"
	PASSWORD = "<server_admin_password>"
)

func checkError(err error) {
	if err != nil {
		panic(err)
	}
}

func main() {

	// Initialize connection string.
	var connectionString string = 
		fmt.Sprintf("host=%s user=%s password=%s dbname=%s sslmode=require", HOST, USER, PASSWORD, DATABASE)

	// Initialize connection object.
	db, err := sql.Open("postgres", connectionString)
	checkError(err)

	err = db.Ping()
	checkError(err)
	fmt.Println("Successfully created connection to database")

	// Delete some data from table.
	sql_statement := "DELETE FROM inventory WHERE name = $1;"
	_, err = db.Exec(sql_statement, "orange")
	checkError(err)
	fmt.Println("Deleted 1 row of data")
}

Rensa resurser

Om du vill rensa alla resurser som används under den här snabbstarten tar du bort resursgruppen med hjälp av följande kommando:

az group delete \
    --name $AZ_RESOURCE_GROUP \
    --yes

Feedback

Var den här sidan till hjälp?

Last updated on 2026-07-14

Snabbstart: Använda Go-språk för att ansluta och fråga efter data i Azure Database for PostgreSQL flexibel server

Förutsättningar

Installera Go och pq connector

Hämta anslutningsinformation

Skapa och köra Go-kod

Ansluta och skapa en tabell

Läs data

Uppdatera datainformation

Ta bort data

Rensa resurser

Relaterat innehåll

Feedback

Ytterligare resurser