Azure-Funktionsdatenbank-Verbindungszeichenfolge

Am besten fügen Sie dazu eine Verbindungszeichenfolge aus dem Azure-Portal hinzu:

• Klicken Sie auf Ihrer Funktionsanwendungsoberfläche auf Funktionsanwendungseinstellungen
• Einstellungen/Anwendungseinstellungen
• Fügen Sie Verbindungszeichenfolgen hinzu

Sie sind dann mit derselben Logik verfügbar, als wären sie in einer web.config, z.

var conn = System.Configuration.ConfigurationManager
                 .ConnectionStrings["MyConn"].ConnectionString;

Wenn Sie eine nicht .NET-Sprache verwenden, können Sie stattdessen App-Einstellungen verwenden, die zur Laufzeit zu einfachen Umgebungsvariablen werden, auf die Ihre Funktionen zugreifen können.

Jan_V fast genagelt, was mich veranlasst hat, im local.settings.json zu experimentieren

{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "UseDevelopmentStorage=true;",
    "AzureWebJobsDashboard": ""
  },
  "ConnectionStrings": {
    "MyConnectionString": "[YourConnectionStringHere]"
  }
}

Dadurch können Sie den ConfigurationManager.ConnectionStrings[] verwenden, den wir alle kennen.

var sqlConnection = ConfigurationManager
                   .ConnectionStrings["MyConnectionString"].ConnectionString;

Ich habe hier einige ähnliche Fragen und Antworten durchlaufen. Viele von ihnen sind entweder irreführend oder gehen davon aus, dass sich alle auf derselben Ebene befinden und wissen, wie die Azure-Funktionen funktionieren. Für Neulinge wie mich gibt es keine Antwort. Ich möchte hier meine Lösung Schritt für Schritt zusammenfassen.

1. das Wichtigste ist, dass wir die Datei local.settings.json verstehenIS NICHT FÜR Azure. es ist Ihre App in der lokalen auszuführen, da der Name ist. Die Lösung hat also nichts mit dieser Datei zu tun.

2. App.Config oder Web.Config funktioniert nicht für Verbindungszeichenfolgen der Azure-Funktion. Wenn Sie über eine Datenbankschichtbibliothek verfügen, können Sie die Verbindungszeichenfolge nicht wie in Asp.Net-Anwendungen mit einer dieser Verbindungen überschreiben.

3. Damit Sie damit arbeiten können, müssen Sie Ihre Verbindungszeichenfolge im Azure-Portal unter Application Settings in Ihrer Azure-Funktion definieren. Es gibt Verbindungszeichenfolgen. Dort sollten Sie Ihre Verbindungszeichenfolge Ihres DBContext kopieren. Wenn es sich um edmx handelt, sieht es wie folgt aus. Es gibt einen Verbindungstyp, ich verwende es SQlAzure, aber ich habe es mit Custom getestet (jemand behauptet, dass es nur mit Custom funktioniert) funktioniert mit beiden. 

metadata = res: // /Models.myDB.csdl | res:// / Models.myDB.ssdl | res: //*/Models.myDB.msl; provider = System.Data.SqlClient; provider Verbindungszeichenfolge = 'Datenquelle = [yourdbURL]; initial catalog = myDB; persistente Sicherheitsinformationen = True; Benutzer id = xxxx; Kennwort = xxx; MultipleActiveResultSets = True; App = EntityFramework

4. Nachdem Sie dies eingerichtet haben, müssen Sie die URL in Ihrer Anwendung lesen und den DBContext angeben. DbContext implementiert einen Konstruktor mit dem Parameter für die Verbindungszeichenfolge. Standardmäßig enthält der Konstruktor keine Parameter, Sie können dies jedoch erweitern. Wenn Sie POCO-Klassen verwenden, können Sie die DbContext-Klasse einfach ändern. Wenn Sie mit der Datenbank generierte Edmx-Klassen wie ich verwenden, möchten Sie die automatisch generierten Edmx-Klassen nicht berühren. Stattdessen möchten Sie Teilklassen im gleichen Namespace erstellen und diese Klasse wie folgt erweitern.

Dies ist automatisch DbContext generiert

namespace myApp.Data.Models
{   

    public partial class myDBEntities : DbContext
    {
        public myDBEntities()
           : base("name=myDBEntities")
        {
        }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            throw new UnintentionalCodeFirstException();
        }

}

dies ist die neue Teilklasse, die Sie erstellen

namespace myApp.Data.Models
{
    [DbConfigurationType(typeof(myDBContextConfig))]
    partial class myDBEntities
    {

        public myDBEntities(string connectionString) : base(connectionString)
        {
        }
    }

      public  class myDBContextConfig : DbConfiguration
        {
            public myDBContextConfig()
            {
                SetProviderServices("System.Data.EntityClient", 
                SqlProviderServices.Instance);
                SetDefaultConnectionFactory(new SqlConnectionFactory());
            }
        }
    }

5. Schließlich können Sie die Verbindungszeichenfolge aus den Azure-Einstellungen in Ihrem Azure Function-Projekt mit dem folgenden Code abrufen und Ihrem DbContext MyDBEntities den Namen geben, den Sie im Azure-Portal für Ihre Verbindungszeichenfolge angegeben haben.

var connString = ConfigurationManager.ConnectionStrings["myDBEntities"].ConnectionString;


 using (var dbContext = new myDBEntities(connString))
{
        //TODO:
}

Configuration Manager wird in Functions Runtime v2 durch das neue Asp.Net Core Configuration System ersetzt. 

Wenn Sie also .Net Core verwenden, sollten Sie den Artikel von John Gallants Blog folgen: https://blog.jongallant.com/2018/01/Azure-function-config/

• Funktioniert mit local.settings.json und Einstellungen in Azure-Funktion
• Funktioniert mit App-Einstellungen und Verbindungszeichenfolgen

Die Antwort von Todd De Land funktioniert nur für die lokale Umgebung. Gemäß dieser doc -Datei müssen jedoch für veröffentlichte Azure-Funktionen Verbindungszeichenfolgen als App-Einstellungen gespeichert und von GetEnvironmentVariable abgerufen werden.

Das Hinzufügen von System.Configuration Assembly-Referenz ist nicht erforderlich.

string cs = Environment.GetEnvironmentVariable("MyConnectionString",EnvironmentVariableTarget.Process);

Hier sind die Schritte, um Umgebungszeichenfolgen für sowohl lokale als auch veröffentlichte Umgebungen abrufbar zu machen

1. Um die lokale Umgebung zu unterstützen, geben Sie in local.settings.json Ihre Verbindungszeichenfolgen im Values-Knoten an

2. Um eine veröffentlichte Umgebung zu unterstützen, gehen Sie zu portal.Azure.com > your Azure Function > function node > Application Settings.

3. Rufen Sie schließlich GetEnvironmentVariable von Ihrer Azure-Funktion auf (kann stackoverflow nicht abrufen, um diesen Code korrekt anzuzeigen)

Das ist es.

Ich glaube, dass es üblich ist, Umgebungsvariablen für Azure-Funktionen zu verwenden. Dann können Sie die Umgebungsvariablen in der Azure-Funktion einrichten:

(Funktion App-Einstellungen -> App-Einstellungen konfigurieren -> App-Einstellungen)

Vielleicht wäre es hilfreicher, wenn Sie uns auch mitteilen können, welche Sprache Sie verwenden?

System.Configuration.ConfigurationManager funktioniert nicht mehr mit AzureFunctions . Sie sollten stattdessen ExecutionContext aus Azure.WebJobs verwenden und einen Kontext mit den Einstellungen aus Azure als Parameter in der Run-Methode importieren.

Schauen Sie sich diese Erklärung an: https://blog.jongallant.com/2018/01/Azure-function-config/

einige der oben genannten Vorschläge funktionieren. Es gibt jedoch eine einfachere Möglichkeit, eine Verbindungszeichenfolge festzulegen. Dies geschieht über den Bildschirm "Veröffentlichen", den Sie nach dem Klicken auf die Veröffentlichungseinstellung sehen. siehe Bild aus der Dokumentation hier

Das Folgende funktionierte für mich sowohl lokal als auch in Azure für eine http-Triggerfunktion, die cosmos db abfragt

Microsoft.Azure.WebJobs.Extensions.CosmosDB Nuget-Paketverweis auf Projekt hinzugefügt

einstellungen für Verbindungszeichenfolgen:

local.settings.json

{
  "ConnectionStrings": {
    "CosmosDBConnection": "AccountEndpoint=foobar;"
  }
}

in Azure-Portal > Funktions-Apps > Plattformfunktionen > Konfigurationen > Anwendungseinstellungen > Neue Anwendungseinstellungen > Name: CosmosDBConnectionValue: AccountEndpoint=foobar; Update > speichern

beispiel c # Azure-Funktion

public static async Task<IActionResult> Run(
           [HttpTrigger(AuthorizationLevel.Anonymous, "get")] HttpRequest req,
           [CosmosDB(databaseName:"dbName",
                     collectionName:"collectionName",
                     ConnectionStringSetting = "CosmosDBConnection")] DocumentClient documentClient, 
           ILogger log){
             .....
           }

Ich habe versucht, unter Code-Snippet in meiner lokalen Datenbank, die einfach zu sein scheint. Werfen wir einen Blick.

Nuget Extention:

Laden Sie die folgende Referenz aus dem Teil Nuget Package Manager Ihres Projekts Dependencies herunter

using System.Data.SqlClient;

local.settings.json:

{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
    "FUNCTIONS_WORKER_RUNTIME": "dotnet",
    "sqldb_connection": "Data Source=.;Initial Catalog=DatabaseName;Connection Timeout=30;Integrated Security=True;"
  }
}

Verbindung auf Funktionskörper lesen:

// Datenbankverbindung lesen

        var sqlConnection = Environment.GetEnvironmentVariable("sqldb_connection");

Funktion Lese-/Schreibvorgang unter Verwendung der Verbindungszeichenfolge:

// Convert all request perameter into Json object

                var content = req.Content;
                string jsonContent = content.ReadAsStringAsync().Result;
                dynamic requestPram = JsonConvert.DeserializeObject<AzureSqlTableClass>(jsonContent);

                // Validate required param

                if (string.IsNullOrEmpty(requestPram.FirstName))
                {
                    return req.CreateResponse(HttpStatusCode.OK, "Please enter First Name!");
                }
                if (string.IsNullOrEmpty(requestPram.LastName))
                {
                    return req.CreateResponse(HttpStatusCode.OK, "Please enter Last Name!");
                }



                //Read database Connection

                var sqlConnection = Environment.GetEnvironmentVariable("sqldb_connection");
                var responseResults = 0;

                //Read Write Uisng Connection String

                using (SqlConnection conn = new SqlConnection(sqlConnection))
                {
                    conn.Open();
                    var text = "INSERT INTO AzureSqlTable VALUES ('" + requestPram.FirstName + "', '" + requestPram.LastName + "', '" + requestPram.Email + "') ";

                    using (SqlCommand cmd = new SqlCommand(text, conn))
                    {
                        responseResults = await cmd.ExecuteNonQueryAsync();
                    }
                    conn.Close();
                }

                return req.CreateResponse(HttpStatusCode.OK, responseResults);

Hinweis: Ersetzen Sie beim Veröffentlichen Ihrer Funktion in Azure portal nur die Verbindungszeichenfolge in local.settings.json. Es wird dementsprechend funktionieren. Siehe den Screenshot unten:

Probieren Sie diese Methode aus.

public static string GetConnectionString(string name) { string conStr = System.Environment.GetEnvironmentVariable($"ConnectionStrings:{name}", EnvironmentVariableTarget.Process); if (string.IsNullOrEmpty(conStr)) // Azure Functions App Service naming convention conStr = System.Environment.GetEnvironmentVariable($"SQLAZURECONNSTR_{name}", EnvironmentVariableTarget.Process); return conStr; }