Inicio rápido: usar el lenguaje Go para conectarse y consultar datos en Servidor flexible de Azure Database for PostgreSQL

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). Se indica cómo usar instrucciones SQL para consultar, insertar, actualizar y eliminar datos en la base de datos. Este artículo parte de la base de que ya está familiarizado con el desarrollo con Go, pero que es nuevo en el uso de Azure Database for PostgreSQL.

Prerrequisitos

En este inicio rápido se usan los recursos creados en Creación de una instancia de Azure Database for PostgreSQL como punto de partida.

Importante

Use un servidor con acceso público (direcciones IP permitidas) habilitada para este inicio rápido. El uso de un servidor con Acceso privado (integración con red virtual) habilitado para completar este inicio rápido podría implicar pasos adicionales que no se describen.

Asegúrese de que la dirección IP desde la que se conecta se agrega a las reglas de firewall del servidor mediante el portal de Azure o CLI de Azure.

Instalación de Go y del conector pq

Instale Go y el controlador Pure Go Postgres (pq) en su máquina. Dependiendo de la plataforma, siga los pasos correspondientes:

  1. Descargue e instale Go para Microsoft Windows de acuerdo con las instrucciones de instalación.

  2. En el menú Inicio, inicie el símbolo del sistema.

  3. Cree una carpeta para el proyecto, como mkdir %USERPROFILE%\go\src\postgresqlgo.

  4. Cambie el directorio a la carpeta de proyecto, por ejemplo 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 GOPATH=%USERPROFILE%\go.

  6. Ejecute go mod init para crear un módulo en el directorio actual. Por ejemplo: go mod init postgresqlgo.

    • El <module_path> parámetro suele ser una ubicación en un repositorio de GitHub, como github.com/<your_github_account_name>/<directory>.
    • Al crear una aplicación de línea de comandos como prueba y no publicar la aplicación, <module_path> no es necesario hacer referencia a una ubicación real. Por ejemplo: postgresqlgo.

  7. Instale el controlador Pure Go Postgres (pq) mediante la ejecución del comando go get github.com/lib/pq.

    En resumen, instale Go y después ejecute estos comandos en el símbolo del sistema:

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

Obtención de información sobre la conexión

Obtenga la información de conexión necesaria para conectarse a Azure Database for PostgreSQL. Necesita el nombre completo del servidor y las credenciales de autenticación.

  1. Inicie sesión en Azure Portal.
  2. En el menú izquierdo de Azure Portal, seleccione Todos los recursos y busque el servidor que creó (por ejemplo , mydemoserver).
  3. Seleccione el nombre del servidor.
  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. Si olvida la contraseña, puede restablecerla en este panel.

Compilación y ejecución del código de Go

  1. Para escribir código de Go, use un editor de texto sin formato, como bloc de notas en Microsoft Windows, Nano en Ubuntu o TextEdit en macOS. Si prefiere un entorno de desarrollo interactivo (IDE) más completo, pruebe GoLand by JetBrains, Visual Studio Code por Microsoft o Atom.
  2. Pegue el código Go de las siguientes secciones en archivos de texto y guárdelos en la carpeta de su proyecto con la extensión de archivo *.go, como la ruta de Windows %USERPROFILE%\go\src\postgresqlgo\createtable.go o la ruta de Linux ~/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. Al crear el servidor Azure Database for PostgreSQL, se crea una base de datos denominada postgres. Puede usar esa base de datos u otra que cree.
  4. Inicie el símbolo del sistema o el shell de Bash. Cambie el directorio a la carpeta de proyecto. Por ejemplo, en Windows, use cd %USERPROFILE%\go\src\postgresqlgo\. En Linux, use 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.
  5. Ejecute el código escribiendo el comando go run createtable.go para compilar la aplicación y ejecútela.
  6. Como alternativa, para compilar el código en una aplicación nativa, use go build createtable.go. A continuación, inicie createtable.exe para ejecutar la aplicación.

Conexión y creación de una tabla

Use el código siguiente para conectarse y crear una tabla mediante la instrucción CREATE TABLE SQL, seguida de instrucciones INSERT INTO SQL para agregar filas a la tabla.

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.

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(). Durante todo el proceso se usa un identificador de base de datos, que contiene el grupo de conexiones del servidor de base de datos. El código llama al método Exec() varias veces para ejecutar varios comandos SQL. Cada vez que un método checkError() personalizado comprueba si se produjo un error y entra en pánico para salir si se produce un error.

Reemplace los parámetros HOST, DATABASE, USER y PASSWORD por sus propios valores.

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

Leer datos

Use el código siguiente para conectarse y leer los datos mediante la instrucción SQL SELECT.

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.

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(). Durante todo el proceso se usa un identificador de base de datos, que contiene el grupo de conexiones del servidor de base de datos. La consulta de selección se ejecuta mediante una llamada a method db. Query() y las filas resultantes se mantienen en una variable de tipo rows. El código lee los valores de las columnas de la fila actual mediante el método rows.Scan() e itera sobre las filas mediante el iterador rows.Next() hasta que no haya más filas. Los valores de columna de cada fila se imprimen en 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.

Reemplace los parámetros HOST, DATABASE, USER y PASSWORD por sus propios valores.

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

Actualización de datos

Use el código siguiente para conectarse y actualizar los datos mediante la instrucción SQL UPDATE.

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.

El código llama al método sql. Open() para conectarse a Azure Database for PostgreSQL base de datos y comprueba la conexión mediante el método 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. El código llama al método Exec() para ejecutar la instrucción SQL que actualiza la tabla. Se usa un método checkError() personalizado para comprobar si se ha producido un error y, en caso afirmativo, avisa para salir.

Reemplace los parámetros HOST, DATABASE, USER y PASSWORD por sus propios valores.

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

Eliminación de datos

Use el código siguiente para conectarse a la base de datos y eliminar datos mediante una instrucción DELETE SQL.

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.

El código llama al método sql. Open() para conectarse a Azure Database for PostgreSQL y comprueba la conexión mediante el método db. Ping(). Un descriptor de base de datos mantiene el grupo de conexiones del servidor de bases de datos y se utiliza en toda la aplicación. El código llama al método Exec() para ejecutar la instrucción SQL que elimina una fila de la tabla. Un método personalizado checkError() comprueba si se ha producido un error y se cierra si se produce un error.

Reemplace los parámetros HOST, DATABASE, USER y PASSWORD por sus propios valores.

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

Limpieza de recursos

Para limpiar todos los recursos usados durante este inicio rápido, elimine el grupo de recursos mediante el siguiente comando:

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

Contenido relacionado

  • Last updated on