Cómo configurar la conexión a bases de datos en Entity Framework

4 min
Iniciación

Hemos visto que Entity Framework es compatible con distintas bases de datos, como SQL Server, SQLite y MySQL.

La única diferencia entre uno y otros es cómo configuramos la conexión de la base de datos en nuestro proyecto de Entity Framework.

Pero, aparte de esta configuración, el uso es idéntico e independiente de la base de datos que estemos utilizando.

De hecho, podemos cambiar de podemos cambiar de un proveedor de base de datos a otro sin cambiar nada el código

Así que vamos a ver cómo configurar nuestro proyecto para trabajar con distintos tipos de bases de datos.

Configuración de bases de datos compatibles

Lo primero que tenemos que hacer para configurar una base de datos u otra es instalar el paquete adecuado para el proveedor de base de datos que vayamos a utilizar.

Aquí algunos ejemplos de proveedores:

SQL Server

SQL Server: Es el sistema de bases de datos relacionales más utilizado con .NET, y se configura fácilmente con EF Core.
```
Install-Package Microsoft.EntityFrameworkCore.SqlServer
```

Y definiremos la cadena de conexión con

options.UseSqlServer(tu_connection_string)

SQLite

SQLite: SQLite es una base de datos ligera, ideal para aplicaciones de escritorio o de pequeña escala.
```
Install-Package Microsoft.EntityFrameworkCore.Sqlite
```
```
    Y definiremos la cadena de conexión con
```

options.UseSqlite(tu_connection_string)

MySQL

MySQL: Este proveedor permite la integración de EF Core con bases de datos MySQL y MariaDB.
```
Install-Package Pomelo.EntityFrameworkCore.MySql
```

PostgreSQL

PostgreSQL: PostgreSQL es un sistema de bases de datos potente y versátil.
```
Install-Package Npgsql.EntityFrameworkCore.PostgreSQL
```
Y definiremos la cadena de conexión con

options.UseNpgsql(tu_connection_string)

Configuración de la cadena de conexión

Por otro lado, necesitaremos formatear nuestra cadena de conexión según la base de datos que vayamos a utilizar.

La Connection String es un fragmento de texto que contiene la información que necesita Entity Framework para conectarse con tu instancia de la base de datos.

Algunos ejemplos de Connection String son,

SQL Server

SQL Server

"ConnectionStrings": {
  "DefaultConnection": "Server=localhost;Database=MyDatabase;User Id=myUsername;Password=myPassword;"
}

SQLite

SQLite

"ConnectionStrings": {
  "DefaultConnection": "Data Source=MyDatabase.db"
}

MySQL

MySQL

"ConnectionStrings": {
  "DefaultConnection": "Server=localhost;Database=MyDatabase;User=myUsername;Password=myPassword;"
}

PostgreSQL

PostgreSQL

"ConnectionStrings": {
  "DefaultConnection": "Host=localhost;Database=MyDatabase;Username=myUsername;Password=myPassword"
}

Donde guardar la cadena de conexión

Un tema muy importante es dónde guardar la Connection String. Esta generalmente contiene información sensible (como contraseñas, usuarios…) que, evidentemente, no queremos que sean pública o se filtre.

En un proyecto de .NET tenemos distintos sitios seguros donde podemos guardar recursos (como la Connection String) de steam de forma segura, dependiendo del tipo de aplicación y de los requisitos de seguridad y configuración.

Vamos a ver algunos de ellos,

Opción	Usar en…	Seguridad	Facilidad
`appsettings.json` / `app.config`	Local, desarrollo, ASP.NET Core	🔴 Baja	🟢 Alta
Variables de entorno	Producción, servidores	🟢 Alta	🟡 Media
Azure Key Vault	Aplicaciones en Azure	🟢 Muy alta	🟡 Media
User Secrets	Desarrollo local en .NET Core	🟡 Media	🟢 Alta

Aquí están las opciones más comunes:

appsettings.json

Para aplicaciones ASP.NET Core y .NET 5+ (incluyendo Web API, MVC, Blazor), se almacena en appsettings.json dentro de la carpeta raíz del proyecto.

{
  "ConnectionStrings": {
    "MiConexion": "Server=myServer;Database=myDB;User Id=myUser;Password=myPass;"
  }
}

Se accede en código mediante inyección de dependencias

var connectionString = builder.Configuration.GetConnectionString("MiConexion");

app.config

Para aplicaciones .NET Framework y ASP.NET antiguas, se almacena en app.config (para aplicaciones de consola/WPF) o en web.config (para aplicaciones antiguas).

Por ejemplo en app.config / web.config:

<configuration>
  <connectionStrings>
    <add name="MiConexion" connectionString="Server=myServer;Database=myDB;User Id=myUser;Password=myPass;" providerName="System.Data.SqlClient"/>
  </connectionStrings>
</configuration>

Y se accede en código con:

using System.Configuration;
string connStr = ConfigurationManager.ConnectionStrings["MiConexion"].ConnectionString;

Variables de Entorno

También se pueden definir variables e entorno, o en un fichero .env (para Docker, Kubernetes, etc.). Para leerlas en .NET:

string connStr = Environment.GetEnvironmentVariable("DB_CONNECTION_STRING");

Azure Key Vault

Si la aplicación se ejecuta en Azure, es mejor almacenar la Connection String en Azure Key Vault en lugar de archivos de configuración. Se obtiene en código con:

var kvClient = new SecretClient(new Uri("https://my-key-vault.vault.azure.net/"), new DefaultAzureCredential());
string connStr = kvClient.GetSecret("MiConexion").Value;

User Secrets

Si estás en desarrollo, puedes almacenar la conexión en User Secrets para evitar exponer credenciales en appsettings.json. Ejecuta en la terminal:

dotnet user-secrets init
dotnet user-secrets set "ConnectionStrings:MiConexion" "Server=myServer;Database=myDB;User Id=myUser;Password=myPass;"

Y se accede igual que appsettings.json:

var connectionString = builder.Configuration.GetConnectionString("MiConexion");

Ejemplo práctico

Veamos un ejemplo resumen de configuración para SQL Server:

appsettings.json

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=localhost;Database=MiBaseDeDatos;User Id=sa;Password=MiContraseñaSegura;"
  }
}

DbContext

El DbContext es la clase principal de Entity Framework que gestiona la conexión a la base de datos. Para configurarlo, debemos pasar la cadena de conexión al constructor de la clase DbContext.

public class MiContexto : DbContext
{
    public MiContexto(DbContextOptions<MiContexto> options) : base(options)
    {
    }

    public DbSet<MiEntidad> MiEntidades { get; set; }
}

Program.cs

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddDbContext<MiContexto>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

var app = builder.Build();

Para MySQL, utilizamos UseMySql en lugar de UseSqlServer o UseSqlite: