Inicio rápido: Uso del lenguaje Go para conectarse y consultar datos en Azure Database for PostgreSQL: servidor únicoQuickstart: Use Go language to connect and query data in Azure Database for PostgreSQL - Single Server

En este tutorial rápido se muestra cómo conectarse a una instancia de Azure Database for PostgreSQL mediante código escrito en el lenguaje Go (golang).This quickstart demonstrates how to connect to an Azure Database for PostgreSQL using code written in the Go language (golang). Se indica cómo usar instrucciones SQL para consultar, insertar, actualizar y eliminar datos en la base de datos.It shows how to use SQL statements to query, insert, update, and delete data in the database. En este artículo se da por hecho que está familiarizado con el desarrollo mediante Go, pero que nunca ha trabajado con Azure Database para PostgreSQL.This article assumes you are familiar with development using Go, but that you are new to working with Azure Database for PostgreSQL.

PrerrequisitosPrerequisites

En este tutorial rápido se usan como punto de partida los recursos creados en una de estas guías:This quickstart uses the resources created in either of these guides as a starting point:

Instalación de Go y del conector pqInstall Go and pq connector

Instale Go y el controlador Pure Go Postgres (pq) en su máquina.Install Go and the Pure Go Postgres driver (pq) on your own machine. Dependiendo de la plataforma, siga los pasos correspondientes:Depending on your platform, follow the appropriate steps:

WindowsWindows

  1. Descargue e instale Go para Microsoft Windows de acuerdo con las instrucciones de instalación.Download and install Go for Microsoft Windows according to the installation instructions.

  2. En el menú Inicio, inicie el símbolo del sistema.Launch the command prompt from the start menu.

  3. Cree una carpeta para su proyecto, como mkdir %USERPROFILE%\go\src\postgresqlgo.Make a folder for your project, such as mkdir %USERPROFILE%\go\src\postgresqlgo.

  4. Cambie el directorio a la carpeta de proyecto, por ejemplo cd %USERPROFILE%\go\src\postgresqlgo.Change directory into the project folder, such as cd %USERPROFILE%\go\src\postgresqlgo.

  5. Establezca la variable de entorno para GOPATH con el fin de que apunte al directorio de código fuente.Set the environment variable for GOPATH to point to the source code directory. set GOPATH=%USERPROFILE%\go.set GOPATH=%USERPROFILE%\go.

  6. Instale el controlador Pure Go Postgres (pq) mediante la ejecución del comando go get github.com/lib/pq.Install the Pure Go Postgres driver (pq) by running the go get github.com/lib/pq command.

    En resumen, instale Go y después ejecute estos comandos en el símbolo del sistema:In summary, install Go, then run these commands in the command prompt:

    mkdir  %USERPROFILE%\go\src\postgresqlgo
    cd %USERPROFILE%\go\src\postgresqlgo
    set GOPATH=%USERPROFILE%\go
    go get github.com/lib/pq
    

Linux (Ubuntu)Linux (Ubuntu)

  1. Inicie el shell de Bash.Launch the Bash shell.

  2. Instale Go mediante la ejecución de sudo apt-get install golang-go.Install Go by running sudo apt-get install golang-go.

  3. Cree una carpeta para el proyecto en su directorio principal, como mkdir -p ~/go/src/postgresqlgo/.Make a folder for your project in your home directory, such as mkdir -p ~/go/src/postgresqlgo/.

  4. Cambie el directorio a la carpeta, por ejemplo, cd ~/go/src/postgresqlgo/.Change directory into the folder, such as cd ~/go/src/postgresqlgo/.

  5. Establezca la variable de entorno GOPATH para que apunte a un directorio de origen válido, como la carpeta go del directorio principal actual.Set the GOPATH environment variable to point to a valid source directory, such as your current home directory's go folder. En el shell de Bash, ejecute export GOPATH=~/go para agregar el directorio go como GOPATH para la sesión de shell actual.At the bash shell, run export GOPATH=~/go to add the go directory as the GOPATH for the current shell session.

  6. Instale el controlador Pure Go Postgres (pq) mediante la ejecución del comando go get github.com/lib/pq.Install the Pure Go Postgres driver (pq) by running the go get github.com/lib/pq command.

    En resumen, ejecute estos comandos de Bash:In summary, run these bash commands:

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

MacOS de AppleApple macOS

  1. Descargue e instale Go de acuerdo con las instrucciones de instalación que coincidan con su plataforma.Download and install Go according to the installation instructions matching your platform.

  2. Inicie el shell de Bash.Launch the Bash shell.

  3. Cree una carpeta para el proyecto en su directorio principal, como mkdir -p ~/go/src/postgresqlgo/.Make a folder for your project in your home directory, such as mkdir -p ~/go/src/postgresqlgo/.

  4. Cambie el directorio a la carpeta, por ejemplo, cd ~/go/src/postgresqlgo/.Change directory into the folder, such as cd ~/go/src/postgresqlgo/.

  5. Establezca la variable de entorno GOPATH para que apunte a un directorio de origen válido, como la carpeta go del directorio principal actual.Set the GOPATH environment variable to point to a valid source directory, such as your current home directory's go folder. En el shell de Bash, ejecute export GOPATH=~/go para agregar el directorio go como GOPATH para la sesión de shell actual.At the bash shell, run export GOPATH=~/go to add the go directory as the GOPATH for the current shell session.

  6. Instale el controlador Pure Go Postgres (pq) mediante la ejecución del comando go get github.com/lib/pq.Install the Pure Go Postgres driver (pq) by running the go get github.com/lib/pq command.

    En resumen, instale Go y después ejecute estos comandos de Bash:In summary, install Go, then run these bash commands:

    mkdir -p ~/go/src/postgresqlgo/
    cd ~/go/src/postgresqlgo/
    export GOPATH=~/go/
    go get github.com/lib/pq
    

Obtención de información sobre la conexiónGet connection information

Obtenga la información de conexión necesaria para conectarse a Azure Database for PostgreSQL.Get the connection information needed to connect to the Azure Database for PostgreSQL. Necesitará el nombre completo del servidor y las credenciales de inicio de sesión.You need the fully qualified server name and login credentials.

  1. Inicie sesión en Azure Portal.Log in to the Azure portal.
  2. En el menú izquierdo de Azure Portal, haga clic en Todos los recursos y, luego, busque el servidor que ha creado, por ejemplo, mydemoserver.From the left-hand menu in Azure portal, click All resources, and then search for the server you have created (such as mydemoserver).
  3. Haga clic en el nombre del servidor.Click the server name.
  4. En el panel Información general del servidor, anote el nombre del servidor y el nombre de inicio de sesión del administrador del servidor.From the server's Overview panel, make a note of the Server name and Server admin login name. Si olvida la contraseña, puede restablecerla en este panel.If you forget your password, you can also reset the password from this panel. Nombre de servidor de Azure Database for PostgreSQL

Compilación y ejecución del código de GoBuild and run Go code

  1. Para escribir código Golang, puede usar un editor de texto sin formato, como el Bloc de notas en Microsoft Windows, vi o Nano en Ubuntu, o TextEdit en macOS.To write Golang code, you can use a plain text editor, such as Notepad in Microsoft Windows, vi or Nano in Ubuntu, or TextEdit in macOS. Si prefiere un entorno de desarrollo integrado (IDE) más enriquecido, pruebe GoLand de Jetbrains, Visual Studio Code de Microsoft o Atom.If you prefer a richer Interactive Development Environment (IDE) try GoLand by Jetbrains, Visual Studio Code by Microsoft, or Atom.
  2. Pegue el código de Golang de las secciones siguientes en archivos de texto y guárdelos en la carpeta del proyecto con la extensión de archivo *.go, como la ruta de acceso de Windows %USERPROFILE%\go\src\postgresqlgo\createtable.go o la ruta de acceso de Linux ~/go/src/postgresqlgo/createtable.go.Paste the Golang code from the following sections into text files, and save into your project folder with file extension *.go, such as Windows path %USERPROFILE%\go\src\postgresqlgo\createtable.go or Linux path ~/go/src/postgresqlgo/createtable.go.
  3. Busque las constantes HOST, DATABASE, USER y PASSWORD en el código y reemplace los valores de ejemplo con sus propios valores.Locate the HOST, DATABASE, USER, and PASSWORD constants in the code, and replace the example values with your own values.
  4. Inicie el símbolo del sistema o el shell de Bash.Launch the command prompt or bash shell. Cambie el directorio a la carpeta de proyecto.Change directory into your project folder. Por ejemplo, en Windows cd %USERPROFILE%\go\src\postgresqlgo\.For example, on Windows cd %USERPROFILE%\go\src\postgresqlgo\. En Linux cd ~/go/src/postgresqlgo/.On Linux cd ~/go/src/postgresqlgo/. Algunos de los entornos de IDE mencionados ofrecen funcionalidades de depuración y de tiempo de ejecución sin necesidad de comandos de shell.Some of the IDE environments mentioned offer debug and runtime capabilities without requiring shell commands.
  5. Ejecute el código escribiendo el comando go run createtable.go para compilar la aplicación y ejecútela.Run the code by typing the command go run createtable.go to compile the application and run it.
  6. Además, para compilar el código en una aplicación nativa, go build createtable.go, inicie createtable.exe para ejecutar la aplicación.Alternatively, to build the code into a native application, go build createtable.go, then launch createtable.exe to run the application.

Conexión y creación de una tablaConnect and create a table

Use el código siguiente para conectarse y crear una tabla mediante la instrucción SQL CREATE TABLE, seguida de las instrucciones SQL INSERT INTO para agregar filas a la tabla.Use the following code to connect and create a table using CREATE TABLE SQL statement, followed by INSERT INTO SQL statements to add rows into the table.

El código importa tres paquetes: el paquete sql, el paquete pq, como controlador para la comunicación con el servidor de PostgreSQL, y el paquete fmt para la entrada y la salida impresas en la línea de comandos.The code imports three packages: the sql package, the pq package as a driver to communicate with the PostgreSQL server, and the fmt package for printed input and output on the command line.

El código llama al método sql.Open() para conectarse a la base de datos de Azure Database for PostgreSQL y comprueba la conexión mediante el método db.Ping().The code calls method sql.Open() to connect to Azure Database for PostgreSQL database, and checks the connection using method db.Ping(). Durante todo el proceso se usa un identificador de base de datos, que contiene el grupo de conexiones del servidor de base de datos.A database handle is used throughout, holding the connection pool for the database server. El código llama al método Exec() varias veces para ejecutar varios comandos SQL.The code calls the Exec() method several times to run several SQL commands. En todo momento, un método checkError() personalizado comprueba si se ha producido un error y, en caso afirmativo, avisa para salir.Each time a custom checkError() method checks if an error occurred and panic to exit if an error does occur.

Reemplace los parámetros HOST, DATABASE, USER y PASSWORD por sus propios valores.Replace the HOST, DATABASE, USER, and PASSWORD parameters with your own values.

package main

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

const (
    // Initialize connection constants.
    HOST     = "mydemoserver.postgres.database.azure.com"
    DATABASE = "mypgsqldb"
    USER     = "mylogin@mydemoserver"
    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")
}

Lectura de datosRead data

Use el código siguiente para conectarse y leer los datos mediante la instrucción SQL SELECT.Use the following code to connect and read the data using a SELECT SQL statement.

El código importa tres paquetes: el paquete sql, el paquete pq, como controlador para la comunicación con el servidor de PostgreSQL, y el paquete fmt para la entrada y la salida impresas en la línea de comandos.The code imports three packages: the sql package, the pq package as a driver to communicate with the PostgreSQL server, and the fmt package for printed input and output on the command line.

El código llama al método sql.Open() para conectarse a la base de datos de Azure Database for PostgreSQL y comprueba la conexión mediante el método db.Ping().The code calls method sql.Open() to connect to Azure Database for PostgreSQL database, and checks the connection using method db.Ping(). Durante todo el proceso se usa un identificador de base de datos, que contiene el grupo de conexiones del servidor de base de datos.A database handle is used throughout, holding the connection pool for the database server. Para ejecutar la consulta de selección, se llama al método db.Query() y las filas resultantes se guardan en una variable de tipo rows.The select query is run by calling method db.Query(), and the resulting rows are kept in a variable of type rows. El código lee los valores de los datos de las columnas de la fila actual mediante el método rows.Scan() y recorre las filas mediante el iterador rows.Next() hasta que no existen más filas.The code reads the column data values in the current row using method rows.Scan() and loops over the rows using the iterator rows.Next() until no more rows exist. Los valores de las columnas de cada fila se imprimen en la salida de la consola. En todo momento, se usa un método checkError() personalizado para comprobar si se ha producido un error y, en caso afirmativo, avisa para salir.Each row's column values are printed to the console out. Each time a custom checkError() method is used to check if an error occurred and panic to exit if an error does occur.

Reemplace los parámetros HOST, DATABASE, USER y PASSWORD por sus propios valores.Replace the HOST, DATABASE, USER, and PASSWORD parameters with your own values.

package main

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

const (
    // Initialize connection constants.
    HOST     = "mydemoserver.postgres.database.azure.com"
    DATABASE = "mypgsqldb"
    USER     = "mylogin@mydemoserver"
    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)
        }
    }
}

Actualización de datosUpdate data

Use el código siguiente para conectarse y actualizar los datos mediante la instrucción SQL UPDATE.Use the following code to connect and update the data using an UPDATE SQL statement.

El código importa tres paquetes: el paquete sql, el paquete pq, como controlador para la comunicación con el servidor de Postgres, y el paquete fmt para la entrada y la salida impresas en la línea de comandos.The code imports three packages: the sql package, the pq package as a driver to communicate with the Postgres server, and the fmt package for printed input and output on the command line.

El código llama al método sql.Open() para conectarse a la base de datos de Azure Database for PostgreSQL y comprueba la conexión mediante el método db.Ping().The code calls method sql.Open() to connect to Azure Database for PostgreSQL database, and checks the connection using method db.Ping(). Durante todo el proceso se usa un identificador de base de datos, que contiene el grupo de conexiones del servidor de base de datos.A database handle is used throughout, holding the connection pool for the database server. El código llama al método Exec() para ejecutar la instrucción SQL que actualiza la tabla.The code calls the Exec() method to run the SQL statement that updates the table. Se usa un método checkError() personalizado para comprobar si se ha producido un error y, en caso afirmativo, avisa para salir.A custom checkError() method is used to check if an error occurred and panic to exit if an error does occur.

Reemplace los parámetros HOST, DATABASE, USER y PASSWORD por sus propios valores.Replace the HOST, DATABASE, USER, and PASSWORD parameters with your own values.

package main

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

const (
    // Initialize connection constants.
    HOST     = "mydemoserver.postgres.database.azure.com"
    DATABASE = "mypgsqldb"
    USER     = "mylogin@mydemoserver"
    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")
}

Eliminación de datosDelete data

Use el código siguiente para conectarse y leer los datos mediante la instrucción SQL DELETE.Use the following code to connect and delete the data using a DELETE SQL statement.

El código importa tres paquetes: el paquete sql, el paquete pq, como controlador para la comunicación con el servidor de Postgres, y el paquete fmt para la entrada y la salida impresas en la línea de comandos.The code imports three packages: the sql package, the pq package as a driver to communicate with the Postgres server, and the fmt package for printed input and output on the command line.

El código llama al método sql.Open() para conectarse a la base de datos de Azure Database for PostgreSQL y comprueba la conexión mediante el método db.Ping().The code calls method sql.Open() to connect to Azure Database for PostgreSQL database, and checks the connection using method db.Ping(). Durante todo el proceso se usa un identificador de base de datos, que contiene el grupo de conexiones del servidor de base de datos.A database handle is used throughout, holding the connection pool for the database server. El código llama al método Exec() para ejecutar la instrucción SQL que elimina una fila de la tabla.The code calls the Exec() method to run the SQL statement that deletes a row from the table. Se usa un método checkError() personalizado para comprobar si se ha producido un error y, en caso afirmativo, avisa para salir.A custom checkError() method is used to check if an error occurred and panic to exit if an error does occur.

Reemplace los parámetros HOST, DATABASE, USER y PASSWORD por sus propios valores.Replace the HOST, DATABASE, USER, and PASSWORD parameters with your own values.

package main

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

const (
    // Initialize connection constants.
    HOST     = "mydemoserver.postgres.database.azure.com"
    DATABASE = "mypgsqldb"
    USER     = "mylogin@mydemoserver"
    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")
}

Limpieza de recursosClean up resources

Para limpiar todos los recursos utilizados durante esta guía de inicio rápido, elimine el grupo de recursos con el siguiente comando:To clean up all resources used during this quickstart, delete the resource group using the following command:

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

Pasos siguientesNext steps