Avvio rapido: Usare il linguaggio Go per connettersi ai dati ed eseguire query in Database di Azure per MySQL

Questa guida introduttiva illustra come connettersi a un database di Azure per MySQL dalle piattaforme Windows, Ubuntu Linux e Apple macOS usando il linguaggio Go . Spiega come usare le istruzioni SQL per eseguire query, inserire, aggiornare ed eliminare dati nel database. Questo argomento presuppone che tu abbia familiarità con lo sviluppo in Go e che tu sia nuovo a lavorare con Azure Database per MySQL.

Prerequisiti

Questa guida introduttiva usa le risorse create in una delle guide seguenti come punto di partenza:

Importante

Per questo avvio rapido è consigliabile usare un server con accesso pubblico (indirizzi IP consentiti). L'uso di un server con accesso privato (integrazione di rete virtuale) abilitato per completare questa guida introduttiva potrebbe comportare passaggi aggiuntivi non trattati.

Assicurati che gli indirizzi IP da cui ti connetti vengano aggiunti alle regole del firewall del server usando il portale di Azure o l'interfaccia della riga di comando di Azure.

Installare Go e il connettore MySQL

Installare Go e il driver go-sql per MySQL nel computer. A seconda della piattaforma, seguire le istruzioni nella sezione appropriata:

Scaricare e installare Go per Microsoft Windows seguendo le istruzioni di installazione.
Avviare il prompt dei comandi dal menu Start.
Creare una cartella per il progetto, ad esempio mkdir %USERPROFILE%\go\src\mysqlgo.
Passare alla cartella del progetto, ad esempio cd %USERPROFILE%\go\src\mysqlgo.
Impostare la variabile di ambiente per GOPATH in modo che punti alla directory del codice sorgente: set GOPATH=%USERPROFILE%\go.
Eseguire go mod init per creare un modulo nella directory corrente. Ad esempio: go mod init mysqlgo.
- Il parametro <module_path> è in genere una posizione in un repository GitHub, ad esempio github.com/<your_github_account_name>/<directory>.
- Per le app della riga di comando di test, <module_path> potrebbe non fare riferimento a una posizione effettiva.
Installare il driver go-sql per MySQL eseguendo il comando go get github.com/go-sql-driver/mysql.

In sintesi, installare Go e quindi eseguire questi comandi nel prompt dei comandi:
```
mkdir  %USERPROFILE%\go\src\mysqlgo
cd %USERPROFILE%\go\src\mysqlgo
set GOPATH=%USERPROFILE%\go
go mod init mysqlgo
go get github.com/go-sql-driver/mysql
```

Avviare la shell Bash.
Installare Go eseguendo sudo apt-get install golang-go.
Creare una cartella per il progetto nella home directory, ad esempio mkdir -p ~/go/src/mysqlgo/.
Passare alla cartella, ad esempio cd ~/go/src/mysqlgo/.
Impostare la variabile di ambiente GOPATH in modo che punti a una directory di origine valida, ad esempio la cartella go della home directory corrente. Nella shell Bash eseguire export GOPATH=~/go per aggiungere la Go directory come GOPATH per la sessione della shell corrente.
Eseguire go mod init per creare un modulo nella directory corrente. Ad esempio: go mod init mysqlgo.
- Il parametro <module_path> è in genere una posizione in un repository GitHub, ad esempio github.com/<your_github_account_name>/<directory>.
- Quando si crea un'app da riga di comando come test e non si pubblica l'app, <module_path> non ha bisogno di fare riferimento a una posizione effettiva. Ad esempio: mysqlgo.

Installare il driver go-sql per MySQL eseguendo il comando go get github.com/go-sql-driver/mysql.

In sintesi, eseguire questi comandi Bash:

sudo apt-get install golang-go git -y
mkdir -p ~/go/src/mysqlgo/
cd ~/go/src/mysqlgo/
export GOPATH=~/go/
go mod init mysqlgo
go get github.com/go-sql-driver/mysql

Scaricare e installare Go seguendo le istruzioni di installazione per la piattaforma in uso.
Avviare la shell Bash.
Creare una cartella per il progetto nella home directory, ad esempio mkdir -p ~/go/src/mysqlgo/.
Passare alla cartella, ad esempio cd ~/go/src/mysqlgo/.
Impostare la variabile di ambiente GOPATH in modo che punti a una directory di origine valida, ad esempio la cartella go della home directory corrente. Nella shell Bash eseguire export GOPATH=~/go per aggiungere la directory go come GOPATH per la sessione shell corrente.
Eseguire go mod init per creare un modulo nella directory corrente. Ad esempio: go mod init mysqlgo.
- Il parametro <module_path> è in genere una posizione in un repository GitHub, ad esempio github.com/<your_github_account_name>/<directory>.
- Quando si crea un'app da riga di comando come test e non si pubblica l'app, <module_path> non ha bisogno di fare riferimento a una posizione effettiva. Ad esempio: mysqlgo.
Installare il driver go-sql per MySQL eseguendo il comando go get github.com/go-sql-driver/mysql.

In sintesi, installare Go e quindi eseguire questi comandi Bash:
```
mkdir -p ~/go/src/mysqlgo/
cd ~/go/src/mysqlgo/
export GOPATH=~/go/
go mod init mysqlgo
go get github.com/go-sql-driver/mysql
```

Ottenere informazioni di connessione

Ottenere le informazioni di connessione necessarie per connettersi al database di Azure per MySQL. Sono necessari il nome del server completo e le credenziali di accesso.

Accedere al portale di Azure.
Nel menu a sinistra nel portale di Azure selezionare Tutte le risorse e quindi cercare il server creato, ad esempio mydemoserver.
Selezionare il nome del server.
Nel pannello Panoramica del server prendere nota dei valori riportati in Nome server e Nome di accesso dell'amministratore server. Se si dimentica la password, in questo pannello è anche possibile reimpostarla.

Compilare ed eseguire il codice Go

Per scrivere codice Golang, è possibile utilizzare un semplice editor di testo, come Blocco Note su Microsoft Windows, vi o Nano su Ubuntu, oppure TextEdit su macOS. Se si preferisce un ambiente di sviluppo interattivo (IDE) più completo, provare GoLand con , JetBrains di Microsoft o Atom.
Incollare il codice Go nei file di testo e quindi salvarli nella cartella del progetto con estensione file *.go (ad esempio percorso di Windows %USERPROFILE%\go\src\mysqlgo\createtable.go o percorso ~/go/src/mysqlgo/createtable.goLinux).
Trovare le costanti host, database, user e password nel codice e quindi sostituire i valori di esempio con i propri valori. Un database denominato flexibleserverdb viene creato quando si crea l'istanza del server Database di Azure per MySQL. È possibile usare tale database o un altro database.
Avviare il prompt dei comandi o la shell Bash. Passare alla cartella del progetto, ad esempio cd %USERPROFILE%\go\src\mysqlgo\ in Windows. In Linux cd ~/go/src/mysqlgo/. Alcuni degli editor dell'ambiente di sviluppo integrato indicati offrono funzionalità di debug e di runtime che non richiedono comandi della shell.
Compilare l'applicazione ed eseguirla con il comando go run createtable.go.
In alternativa, per compilare il codice in un'applicazione nativa, digitare go build createtable.go e quindi avviare createtable.exe per eseguire l'applicazione.

Connettersi, creare tabelle e inserire dati

Usare il codice seguente per connettersi al server, creare una tabella e caricare i dati usando un'istruzione SQL INSERT.

Il codice importa tre pacchetti: il pacchetto SQL, il driver go sql per MySql come driver per comunicare con il database di Azure per MySQL e il pacchetto fmt per l'input e l'output stampati nella riga di comando.

Il codice chiama il metodo sql.Open() per connettersi a Database di Azure per MySQL e controlla la connessione usando il metodo db.Ping(). Viene usato un handle di database, contenente il pool di connessioni per il server di database. Il codice chiama il Exec() metodo più volte per eseguire diversi comandi DDL. Il codice usa Prepare() anche e Exec() per eseguire istruzioni preparate con parametri diversi per inserire tre righe. Ogni volta viene usato un metodo checkError() personalizzato per controllare se si è verificato un errore e un metodo panic per uscire.

Sostituire le costanti host, database, user e password con i propri valori.

package main

import (
    "database/sql"
    "fmt"

    _ "github.com/go-sql-driver/mysql"
)

const (
    host     = "mydemoserver.mysql.database.azure.com"
    database = "flexibleserverdb"
    user     = "myadmin"
    password = "yourpassword"
)

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

func main() {

    // Initialize connection string.
    var connectionString = fmt.Sprintf("%s:%s@tcp(%s:3306)/%s?allowNativePasswords=true&tls=true", user, password, host, database)

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

    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.
    sqlStatement, err := db.Prepare("INSERT INTO inventory (name, quantity) VALUES (?, ?);")
    res, err := sqlStatement.Exec("banana", 150)
    checkError(err)
    rowCount, err := res.RowsAffected()
    fmt.Printf("Inserted %d row(s) of data.\n", rowCount)

    res, err = sqlStatement.Exec("orange", 154)
    checkError(err)
    rowCount, err = res.RowsAffected()
    fmt.Printf("Inserted %d row(s) of data.\n", rowCount)

    res, err = sqlStatement.Exec("apple", 100)
    checkError(err)
    rowCount, err = res.RowsAffected()
    fmt.Printf("Inserted %d row(s) of data.\n", rowCount)
    fmt.Println("Done.")
}

Leggere i dati

Usare il codice seguente per connettersi e leggere i dati usando un'istruzione SQL SELECT.

Il codice chiama il metodo sql.Open() per la connessione al database di Azure per MySQL e controlla la connessione usando il metodo db.Ping(). Viene usato un handle di database, contenente il pool di connessioni per il server di database. Il codice chiama il metodo Query() per eseguire il comando SELECT. Esegue quindi il metodo Next() per scorrere il set di risultati e Scan() per analizzare i valori delle colonne, salvando il valore nelle variabili. Ogni volta viene usato un metodo checkError() personalizzato per controllare se si è verificato un errore e un metodo panic per uscire.

Sostituire le costanti host, database, user e password con i propri valori.

package main

import (
    "database/sql"
    "fmt"

    _ "github.com/go-sql-driver/mysql"
)

const (
    host     = "mydemoserver.mysql.database.azure.com"
    database = "flexibleserverdb"
    user     = "myadmin"
    password = "yourpassword"
)

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

func main() {

    // Initialize connection string.
    var connectionString = fmt.Sprintf("%s:%s@tcp(%s:3306)/%s?allowNativePasswords=true&tls=true", user, password, host, database)

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

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

    // Variables for printing column data when scanned.
    var (
        id       int
        name     string
        quantity int
    )

    // Read some data from the table.
    rows, err := db.Query("SELECT id, name, quantity from inventory;")
    checkError(err)
    defer rows.Close()
    fmt.Println("Reading data:")
    for rows.Next() {
        err := rows.Scan(&id, &name, &quantity)
        checkError(err)
        fmt.Printf("Data row = (%d, %s, %d)\n", id, name, quantity)
    }
    err = rows.Err()
    checkError(err)
    fmt.Println("Done.")
}

Aggiornamento dei dati

Usare il codice seguente per connettersi e aggiornare i dati usando un'istruzione SQL UPDATE.

Il codice chiama il metodo sql.Open() per la connessione al database di Azure per MySQL e controlla la connessione usando il metodo db.Ping(). Viene usato un handle di database, contenente il pool di connessioni per il server di database. Il codice chiama il metodo Exec() per eseguire il comando UPDATE. Ogni volta viene usato un metodo checkError() personalizzato per controllare se si è verificato un errore e un metodo panic per uscire.

Sostituire le costanti host, database, user e password con i propri valori.

package main

import (
    "database/sql"
    "fmt"

    _ "github.com/go-sql-driver/mysql"
)

const (
    host     = "mydemoserver.mysql.database.azure.com"
    database = "flexibleserverdb"
    user     = "myadmin"
    password = "yourpassword"
)

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

func main() {

    // Initialize connection string.
    var connectionString = fmt.Sprintf("%s:%s@tcp(%s:3306)/%s?allowNativePasswords=true&tls=true", user, password, host, database)

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

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

    // Modify some data in table.
    rows, err := db.Exec("UPDATE inventory SET quantity = ? WHERE name = ?", 200, "banana")
    checkError(err)
    rowCount, err := rows.RowsAffected()
    fmt.Printf("Updated %d row(s) of data.\n", rowCount)
    fmt.Println("Done.")
}

Eliminare dati

Usare il codice seguente per connettersi e rimuovere i dati usando un'istruzione SQL DELETE.

Il codice chiama il metodo sql.Open() per la connessione al database di Azure per MySQL e controlla la connessione usando il metodo db.Ping(). Viene usato un handle di database, contenente il pool di connessioni per il server di database. Il codice chiama il metodo Exec() per eseguire il comando DELETE. Ogni volta viene usato un metodo checkError() personalizzato per controllare se si è verificato un errore e un metodo panic per uscire.

Sostituire le costanti host, database, user e password con i propri valori.

package main

import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
)

const (
    host     = "mydemoserver.mysql.database.azure.com"
    database = "flexibleserverdb"
    user     = "myadmin"
    password = "yourpassword"
)

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

func main() {

    // Initialize connection string.
    var connectionString = fmt.Sprintf("%s:%s@tcp(%s:3306)/%s?allowNativePasswords=true&tls=true", user, password, host, database)

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

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

    // Modify some data in table.
    rows, err := db.Exec("DELETE FROM inventory WHERE name = ?", "orange")
    checkError(err)
    rowCount, err := rows.RowsAffected()
    fmt.Printf("Deleted %d row(s) of data.\n", rowCount)
    fmt.Println("Done.")
}

Pulire le risorse

Per pulire tutte le risorse usate in questo argomento di avvio rapido, eliminare il gruppo di risorse con il comando seguente:

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

Passaggio successivo

Eseguire la migrazione del database del server flessibile Database di Azure per MySQL usando l'importazione e l'esportazione

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-01-08

Condividi tramite

Avvio rapido: Usare il linguaggio Go per connettersi ai dati ed eseguire query in Database di Azure per MySQL

Prerequisiti

Installare Go e il connettore MySQL

Ottenere informazioni di connessione

Compilare ed eseguire il codice Go

Connettersi, creare tabelle e inserire dati

Leggere i dati

Aggiornamento dei dati

Eliminare dati

Pulire le risorse

Passaggio successivo

Commenti e suggerimenti

Risorse aggiuntive