Connettiti da Cloud Build

Questa pagina contiene informazioni ed esempi per la connessione a un un'istanza Cloud SQL da un servizio eseguito in Cloud Build.

Cloud SQL è un servizio di database completamente gestito che ti consente di configurare, gestire e amministrare i database relazionali nel cloud.

Cloud Build è un servizio che esegue le build sull'infrastruttura Google Cloud.

configura un'istanza Cloud SQL

  1. Abilita l'API Cloud SQL Admin nel progetto Google Cloud da cui ti connetti, se non l'hai ancora fatto:

    Abilita l'API

  2. Crea un cluster Cloud SQL per un'istanza SQL Server. Ti consigliamo di scegliere Cloud SQL località dell'istanza nella stessa regione del servizio Cloud Run per migliorare la latenza, evitare alcuni costi di networking e ridurre e rischi di errori tra regioni.

    Per impostazione predefinita, Cloud SQL assegna un indirizzo IP pubblico a un nuovo in esecuzione in un'istanza Compute Engine. Puoi anche scegliere di assegnare un indirizzo IP privato. Per maggiori informazioni sulle opzioni di connettività per entrambi, consulta le Panoramica della connessione .

Configura Cloud Build

I passaggi per configurare Cloud Build dipendono dal tipo Indirizzo IP assegnato all'istanza Cloud SQL.

IP pubblico (predefinito)

Assicurati che il tuo l'account di servizio Cloud Build ha IAM ruoli e autorizzazioni necessari per la connessione all'istanza Cloud SQL. L'account di servizio Cloud Build è elencato nella console Google Cloud IAM come Entità [YOUR-PROJECT-NUMBER]@cloudbuild.gserviceaccount.com.

Per visualizzare questo account di servizio nella console Google Cloud, Seleziona la casella di controllo Includi concessioni dei ruoli fornite da Google.

Il tuo account di servizio Cloud Build deve avere uno dei seguenti requisiti Ruoli IAM:

  • Cloud SQL Client (opzione preferita)
  • Cloud SQL Admin
In alternativa, puoi assegnare manualmente le seguenti autorizzazioni IAM:
  • cloudsql.instances.connect
  • cloudsql.instances.get

Se l'account di servizio Cloud Build appartiene a un altro progetto rispetto all'istanza Cloud SQL, quindi l'API Cloud SQL Admin e IAM devi aggiungere autorizzazioni per entrambi i progetti.

IP privato

Per connetterti all'istanza Cloud SQL su IP privato, Cloud Build deve trovarsi nella stessa rete VPC della tua istanza Cloud SQL. Per configurarlo:

  1. Configura una connessione privata tra la rete VPC della tua istanza Cloud SQL e la rete del producer di servizi.
  2. Crea un pool privato di Cloud Build.

Una volta configurata, l'applicazione potrà connettersi direttamente utilizzando il tuo l'indirizzo IP privato dell'istanza e la porta 1433 quando la build viene eseguita nel pool.

Connettiti a Cloud SQL

Dopo aver configurato Cloud Build, puoi connetterti di Cloud SQL.

IP pubblico (predefinito)

Per i percorsi IP pubblici, Cloud Build supporta i socket TCP.

Puoi utilizzare il proxy di autenticazione Cloud SQL in un passaggio di Cloud Build per consentire le connessioni al database. Questa configurazione:

  1. Crea il tuo container ed esegue il push a Container Registry.
  2. Crea un secondo container, copiando il file binario del proxy di autenticazione Cloud SQL.
  3. Utilizzando il secondo container, avvia il proxy di autenticazione Cloud SQL ed esegue tutti i comandi di migrazione.
steps:
  - id: "docker-build"
    name: "gcr.io/cloud-builders/docker"
    args: ["build", "-t", "${_IMAGE_NAME}", "sql-proxy/."]

  - id: "docker-push"
    name: "gcr.io/cloud-builders/docker"
    args: ["push", "${_IMAGE_NAME}"]

  - id: "docker-layer"
    name: "gcr.io/cloud-builders/docker"
    entrypoint: /bin/bash
    args:
      - '-c'
      - |
        echo "FROM $_IMAGE_NAME
        COPY --from=gcr.io/cloud-sql-connectors/cloud-sql-proxy /cloud-sql-proxy /cloudsql/cloud-sql-proxy" > Dockerfile-proxy;

        docker build -f Dockerfile-proxy -t ${_IMAGE_NAME}-proxy .

  # For TCP connections
  - id: "migrate-tcp"
    name: "${_IMAGE_NAME}-proxy"
    dir: sql-proxy
    env:
      - "DATABASE_NAME=${_DATABASE_NAME}"
      - "DATABASE_USER=${_DATABASE_USER}"
      - "DATABASE_HOST=127.0.0.1"
      - "DATABASE_PORT=${_DATABASE_PORT}"
      - "DATABASE_TYPE=${_DATABASE_TYPE}"
    secretEnv:
      - DATABASE_PASS
    entrypoint: /bin/bash
    args:
      - '-c'
      - |
        /cloudsql/cloud-sql-proxy --port ${_DATABASE_PORT} ${_INSTANCE_CONNECTION_NAME} & sleep 2;
        python migrate.py # for example

  # For Unix Socket connections
  - id: "migrate-socket"
    name: "${_IMAGE_NAME}-proxy"
    dir: sql-proxy
    env:
      - "DATABASE_NAME=${_DATABASE_NAME}"
      - "DATABASE_USER=${_DATABASE_USER}"
      - "INSTANCE_CONNECTION_NAME=${_INSTANCE_CONNECTION_NAME}"
      - "DATABASE_TYPE=${_DATABASE_TYPE}"
    secretEnv:
      - DATABASE_PASS
    entrypoint: /bin/bash
    args:
      - '-c'
      - |
        /cloudsql/cloud-sql-proxy --unix-socket /cloudsql ${_INSTANCE_CONNECTION_NAME} & sleep 2;
        if [ $_DATABASE_TYPE = 'mssql' ]; then echo "MSSQL doesn't support Unix Sockets. Skippng."; exit 0; fi;
        python migrate.py # for example.

options:
  dynamic_substitutions: true

substitutions:
  _DATABASE_USER: myuser
  _DATABASE_NAME: mydatabase
  _INSTANCE_CONNECTION_NAME: ${PROJECT_ID}:us-central1:myinstance
  _DATABASE_PORT: '5432'
  _DATABASE_TYPE: postgres
  _DATABASE_PASSWORD_KEY: database_password
  _IMAGE_NAME: gcr.io/${PROJECT_ID}/sample-sql-proxy

availableSecrets:
  secretManager:
    - versionName: projects/$PROJECT_ID/secrets/${_DATABASE_PASSWORD_KEY}/versions/latest
      env: DATABASE_PASS

L'esempio di codice Cloud Build riportato sopra mostra come eseguire un'istanza ipotetica Esegui la migrazione dopo aver eseguito il deployment dell'app di esempio riportata sopra per aggiornare e il database Cloud SQL utilizzando il proxy di autenticazione Cloud SQL e Cloud Build. Per eseguire questo esempio di codice di Cloud Build, i passaggi di configurazione richiesti sono:

  1. Crea un nome cartella sql-proxy
  2. Crea un file Dockerfile nella cartella sql-proxy con la seguente riga di codice per i relativi contenuti: 

    FROM gcr.io/gcp-runtimes/ubuntu_20_0_4

  3. Crea un file cloudbuild.yaml nella cartella sql-proxy.
  4. Aggiorna il file cloudbuild.yaml:
    1. Copia il codice Cloud Build di esempio riportato sopra e incollalo nel file cloudbuild.yaml.
    2. Aggiorna il codice di esempio _DATABASE_TYPE all'interno del blocco substitutions: in modo che sia mssql.
    3. Aggiorna il codice di esempio _DATABASE_PORT all'interno del blocco substitutions: in modo che sia 1433, ovvero la porta utilizzata da SQL Server.
    4. Sostituisci i seguenti valori segnaposto con i valori utilizzati nel progetto:
      • mydatabase
      • myuser
      • myinstance
  5. Crea un secret denominato database_password in Secret Manager.
  6. Crea un file di script migrate.py nella cartella sql-proxy.
    • Lo script può fare riferimento alle seguenti variabili di ambiente e al secret creato nel file cloudbuild.yaml utilizzando i seguenti esempi:
      • os.getenv('DATABASE_NAME')
      • os.getenv('DATABASE_USER')
      • os.getenv('DATABASE_PASS')
      • os.getenv('INSTANCE_CONNECTION_NAME')
    • Per fare riferimento alle stesse variabili da uno script Bash (ad esempio: migrate.sh), utilizza i seguenti esempi:
      • $DATABASE_NAME
      • $DATABASE_USER
      • $DATABASE_PASS
      • $INSTANCE_CONNECTION_NAME
  7. Esegui questo comando gcloud builds submit per creare un container con il proxy di autenticazione Cloud SQL, avvia il proxy di autenticazione Cloud SQL ed esegui lo script migrate.py: 

    gcloud builds submit --config cloudbuild.yaml

IP privato

Per i percorsi IP privati, l'applicazione si connette direttamente tramite pool privati. Questo metodo utilizza TCP per connettersi direttamente a Cloud SQL senza utilizzare il proxy di autenticazione Cloud SQL.

Connetti tramite TCP

Connettiti utilizzando l'indirizzo IP privato dell'istanza Cloud SQL come host e porta 1433.

Python

Per visualizzare questo snippet nel contesto di un'applicazione web, visualizza il file README su GitHub.

import os

import sqlalchemy


def connect_tcp_socket() -> sqlalchemy.engine.base.Engine:
    """Initializes a TCP connection pool for a Cloud SQL instance of SQL Server."""
    # Note: Saving credentials in environment variables is convenient, but not
    # secure - consider a more secure solution such as
    # Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
    # keep secrets safe.
    db_host = os.environ[
        "INSTANCE_HOST"
    ]  # e.g. '127.0.0.1' ('172.17.0.1' if deployed to GAE Flex)
    db_user = os.environ["DB_USER"]  # e.g. 'my-db-user'
    db_pass = os.environ["DB_PASS"]  # e.g. 'my-db-password'
    db_name = os.environ["DB_NAME"]  # e.g. 'my-database'
    db_port = os.environ["DB_PORT"]  # e.g. 1433

    pool = sqlalchemy.create_engine(
        # Equivalent URL:
        # mssql+pytds://<db_user>:<db_pass>@<db_host>:<db_port>/<db_name>
        sqlalchemy.engine.url.URL.create(
            drivername="mssql+pytds",
            username=db_user,
            password=db_pass,
            database=db_name,
            host=db_host,
            port=db_port,
        ),
        # ...
    )

    return pool

Java

Per visualizzare questo snippet nel contesto di un'applicazione web, visualizza il file README su GitHub.

Nota:

  • CLOUD_SQL_CONNECTION_NAME deve essere rappresentato come &lt;MY-PROJECT&gt;:&lt;INSTANCE-REGION&gt;:&lt;INSTANCE-NAME&gt;
  • L'uso dell'argomento ipTypes=PRIVATE forza l'esecuzione di per la connessione all'IP privato associato a un'istanza
  • Consulta i requisiti di versione di fabbrica del socket JDBC per pom.xml qui . 


import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import javax.sql.DataSource;

public class TcpConnectionPoolFactory extends ConnectionPoolFactory {

  // Note: Saving credentials in environment variables is convenient, but not
  // secure - consider a more secure solution such as
  // Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
  // keep secrets safe.
  private static final String DB_USER = System.getenv("DB_USER");
  private static final String DB_PASS = System.getenv("DB_PASS");
  private static final String DB_NAME = System.getenv("DB_NAME");

  private static final String INSTANCE_HOST = System.getenv("INSTANCE_HOST");
  private static final String DB_PORT = System.getenv("DB_PORT");


  public static DataSource createConnectionPool() {
    // The configuration object specifies behaviors for the connection pool.
    HikariConfig config = new HikariConfig();

    // Configure which instance and what database user to connect with.
    config.setJdbcUrl(
        String.format("jdbc:sqlserver://%s:%s;databaseName=%s", INSTANCE_HOST, DB_PORT, DB_NAME));
    config.setUsername(DB_USER); // e.g. "root", "sqlserver"
    config.setPassword(DB_PASS); // e.g. "my-password"


    // ... Specify additional connection properties here.
    // ...

    // Initialize the connection pool using the configuration object.
    return new HikariDataSource(config);
  }
}

Node.js

Per visualizzare questo snippet nel contesto di un'applicazione web, visualizza il file README su GitHub.

const mssql = require('mssql');

// createTcpPool initializes a TCP connection pool for a Cloud SQL
// instance of SQL Server.
const createTcpPool = async config => {
  // Note: Saving credentials in environment variables is convenient, but not
  // secure - consider a more secure solution such as
  // Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
  // keep secrets safe.
  const dbConfig = {
    server: process.env.INSTANCE_HOST, // e.g. '127.0.0.1'
    port: parseInt(process.env.DB_PORT), // e.g. 1433
    user: process.env.DB_USER, // e.g. 'my-db-user'
    password: process.env.DB_PASS, // e.g. 'my-db-password'
    database: process.env.DB_NAME, // e.g. 'my-database'
    options: {
      trustServerCertificate: true,
    },
    // ... Specify additional properties here.
    ...config,
  };
  // Establish a connection to the database.
  return mssql.connect(dbConfig);
};

Vai

Per visualizzare questo snippet nel contesto di un'applicazione web, visualizza il file README su GitHub.

package cloudsql

import (
	"database/sql"
	"fmt"
	"log"
	"os"
	"strings"

	_ "github.com/denisenkom/go-mssqldb"
)

// connectTCPSocket initializes a TCP connection pool for a Cloud SQL
// instance of SQL Server.
func connectTCPSocket() (*sql.DB, error) {
	mustGetenv := func(k string) string {
		v := os.Getenv(k)
		if v == "" {
			log.Fatalf("Fatal Error in connect_tcp.go: %s environment variable not set.\n", k)
		}
		return v
	}
	// Note: Saving credentials in environment variables is convenient, but not
	// secure - consider a more secure solution such as
	// Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
	// keep secrets safe.
	var (
		dbUser    = mustGetenv("DB_USER")       // e.g. 'my-db-user'
		dbPwd     = mustGetenv("DB_PASS")       // e.g. 'my-db-password'
		dbTCPHost = mustGetenv("INSTANCE_HOST") // e.g. '127.0.0.1' ('172.17.0.1' if deployed to GAE Flex)
		dbPort    = mustGetenv("DB_PORT")       // e.g. '1433'
		dbName    = mustGetenv("DB_NAME")       // e.g. 'my-database'
	)

	dbURI := fmt.Sprintf("server=%s;user id=%s;password=%s;port=%s;database=%s;",
		dbTCPHost, dbUser, dbPwd, dbPort, dbName)


	// dbPool is the pool of database connections.
	dbPool, err := sql.Open("sqlserver", dbURI)
	if err != nil {
		return nil, fmt.Errorf("sql.Open: %w", err)
	}

	// ...

	return dbPool, nil
}

C#

Per visualizzare questo snippet nel contesto di un'applicazione web, visualizza il file README su GitHub.

using Microsoft.Data.SqlClient;
using System;

namespace CloudSql
{
    public class SqlServerTcp
    {
        public static SqlConnectionStringBuilder NewSqlServerTCPConnectionString()
        {
            // Equivalent connection string:
            // "User Id=<DB_USER>;Password=<DB_PASS>;Server=<INSTANCE_HOST>;Database=<DB_NAME>;"
            var connectionString = new SqlConnectionStringBuilder()
            {
                // Note: Saving credentials in environment variables is convenient, but not
                // secure - consider a more secure solution such as
                // Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
                // keep secrets safe.
                DataSource = Environment.GetEnvironmentVariable("INSTANCE_HOST"), // e.g. '127.0.0.1'
                // Set Host to 'cloudsql' when deploying to App Engine Flexible environment
                UserID = Environment.GetEnvironmentVariable("DB_USER"),         // e.g. 'my-db-user'
                Password = Environment.GetEnvironmentVariable("DB_PASS"),       // e.g. 'my-db-password'
                InitialCatalog = Environment.GetEnvironmentVariable("DB_NAME"), // e.g. 'my-database'

                // The Cloud SQL proxy provides encryption between the proxy and instance
                Encrypt = false,
            };
            connectionString.Pooling = true;
            // Specify additional properties here.
            return connectionString;
        }
    }
}

Ruby

Per visualizzare questo snippet nel contesto di un'applicazione web, visualizza il file README su GitHub.

tcp: &tcp
  adapter: sqlserver
  # Configure additional properties here.
  # Note: Saving credentials in environment variables is convenient, but not
  # secure - consider a more secure solution such as
  # Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
  # keep secrets safe.
  username: <%= ENV["DB_USER"] %>  # e.g. "my-database-user"
  password: <%= ENV["DB_PASS"] %> # e.g. "my-database-password"
  database: <%= ENV.fetch("DB_NAME") { "vote_development" } %>
  host: <%= ENV.fetch("INSTANCE_HOST") { "127.0.0.1" }%> # '172.17.0.1' if deployed to GAE Flex
  port: <%= ENV.fetch("DB_PORT") { 1433 }%>

PHP

Per visualizzare questo snippet nel contesto di un'applicazione web, visualizza il file README su GitHub.

namespace Google\Cloud\Samples\CloudSQL\SQLServer;

use PDO;
use PDOException;
use RuntimeException;
use TypeError;

class DatabaseTcp
{
    public static function initTcpDatabaseConnection(): PDO
    {
        try {
            // Note: Saving credentials in environment variables is convenient, but not
            // secure - consider a more secure solution such as
            // Cloud Secret Manager (https://cloud.google.com/secret-manager) to help
            // keep secrets safe.
            $username = getenv('DB_USER'); // e.g. 'your_db_user'
            $password = getenv('DB_PASS'); // e.g. 'your_db_password'
            $dbName = getenv('DB_NAME'); // e.g. 'your_db_name'
            $instanceHost = getenv('INSTANCE_HOST'); // e.g. '127.0.0.1' ('172.17.0.1' for GAE Flex)

            // Connect using TCP
            $dsn = sprintf(
                'sqlsrv:server=%s;Database=%s',
                $instanceHost,
                $dbName
            );

            // Connect to the database
            $conn = new PDO(
                $dsn,
                $username,
                $password,
                # ...
            );
        } catch (TypeError $e) {
            throw new RuntimeException(
                sprintf(
                    'Invalid or missing configuration! Make sure you have set ' .
                        '$username, $password, $dbName, and $instanceHost (for TCP mode). ' .
                        'The PHP error was %s',
                    $e->getMessage()
                ),
                $e->getCode(),
                $e
            );
        } catch (PDOException $e) {
            throw new RuntimeException(
                sprintf(
                    'Could not connect to the Cloud SQL Database. Check that ' .
                        'your username and password are correct, that the Cloud SQL ' .
                        'proxy is running, and that the database exists and is ready ' .
                        'for use. For more assistance, refer to %s. The PDO error was %s',
                    'https://cloud.google.com/sql/docs/sqlserver/connect-external-app',
                    $e->getMessage()
                ),
                (int) $e->getCode(),
                $e
            );
        }

        return $conn;
    }
}

Quindi puoi creare un passaggio di Cloud Build per eseguire direttamente il codice. 

steps:
  - id: "docker-build"
    name: "gcr.io/cloud-builders/docker"
    args: ["build", "-t", "${_IMAGE_NAME}", "sql-private-pool/."]

  - id: "docker-push"
    name: "gcr.io/cloud-builders/docker"
    args: ["push", "${_IMAGE_NAME}"]

  - id: "migration"
    name: "${_IMAGE_NAME}"
    dir: sql-private-pool
    env:
      - "DATABASE_NAME=mydatabase"
      - "DATABASE_USER=myuser"
      - "DATABASE_HOST=${_DATABASE_HOST}"
      - "DATABASE_TYPE=${_DATABASE_TYPE}"
    secretEnv:
      - DATABASE_PASS
    entrypoint: python   # for example
    args: ["migrate.py"] # for example

options:
  pool:
    name: projects/$PROJECT_ID/locations/us-central1/workerPools/private-pool
  dynamic_substitutions: true

substitutions:
  _DATABASE_PASSWORD_KEY: database_password
  _DATABASE_TYPE: postgres
  _IMAGE_NAME: gcr.io/${PROJECT_ID}/sample-private-pool

availableSecrets:
  secretManager:
    - versionName: projects/$PROJECT_ID/secrets/${_DATABASE_PASSWORD_KEY}/versions/latest
      env: DATABASE_PASS

L'esempio di codice Cloud Build riportato sopra mostra come eseguire un'istanza ipotetica Esegui la migrazione dopo aver eseguito il deployment dell'app di esempio riportata sopra per aggiornare e il database Cloud SQL con Cloud Build. Per eseguire questo esempio di codice di Cloud Build, i passaggi di configurazione richiesti sono:

  1. Crea un nome cartella sql-private-pool
  2. Crea un file Dockerfile nella cartella sql-private-pool con la seguente riga di codice per i relativi contenuti: 

    FROM gcr.io/gcp-runtimes/ubuntu_20_0_4

  3. Crea un file cloudbuild.yaml nella cartella sql-private-pool.
  4. Aggiorna il file cloudbuild.yaml:
    1. Copia il codice Cloud Build di esempio riportato sopra e incollalo nel file cloudbuild.yaml.
    2. Sostituisci i seguenti valori segnaposto con i valori utilizzati nel progetto:
      • mydatabase
      • myuser
      • databasehost, nel formato host:port.
  5. Crea un secret denominato database_password in Secret Manager.
  6. Crea un file di script migrate.py nella cartella sql-proxy.
    • Lo script può fare riferimento alle seguenti variabili di ambiente e al secret creato nel file cloudbuild.yaml utilizzando i seguenti esempi:
      • os.getenv('DATABASE_NAME')
      • os.getenv('DATABASE_USER')
      • os.getenv('DATABASE_PASS')
      • os.getenv('DATABASE_HOST')
    • Per fare riferimento alle stesse variabili da uno script Bash (ad esempio: migrate.sh), utilizza i seguenti esempi:
      • $DATABASE_NAME
      • $DATABASE_USER
      • $DATABASE_PASS
      • $DATABASE_HOST
  7. Esegui questo comando gcloud builds submit per creare un container con il proxy di autenticazione Cloud SQL, avvia il proxy di autenticazione Cloud SQL ed esegui lo script migrate.py: 

    gcloud builds submit --config cloudbuild.yaml

Best practice e altre informazioni

Puoi utilizzare il proxy di autenticazione Cloud SQL durante il test la tua applicazione in locale. Consulta le guida rapida per l'utilizzo del proxy di autenticazione Cloud SQL per istruzioni dettagliate.

Puoi anche eseguire dei test utilizzando Proxy Cloud SQL tramite un container Docker.

Migrazioni dello schema di database

Configurando Cloud Build per la connessione a Cloud SQL, puoi eseguire lo schema del database per le attività di migrazione in Cloud Build utilizzando lo stesso codice di cui eseguiresti il deployment su qualsiasi altro server completamente gestita.

Utilizzo di Secret Manager

Puoi utilizzare la modalità Secret Manager per includere informazioni sensibili nelle build.