Die Konfigurationsdatei ‚appsettings.json‘ wurde nicht gefunden und ist nicht optional

Question

Der Azure Fehler ist:

.Net Core: Application startup exception: System.IO.FileNotFoundException: The configuration file 'appsettings.json' was not found and is not optional.

Das ist also ein bisschen vage. Ich kann das nicht niederschreiben. Ich versuche, ein .NET-Core-Web-API-Projekt Azure bereitstellen, und ich bin immer diese Fehlermeldung:

:( Oops. 500 Internal Server Error An error occurred while starting the application.

Ich habe nur alte eingesetzt .Net WebAPI ist und sie gearbeitet haben. Ich habe Online-Tutorials verfolgt und sie haben gearbeitet. Aber irgendwie ist mein Projekt pleite. stdoutLogEnabled auf Web.config Aktivieren und Blick auf die Azure-Streaming-Protokolle gibt mir dies:

2016-08-26T02:55:12 Welcome, you are now connected to log-streaming service. 
Application startup exception: System.IO.FileNotFoundException: The configuration file 'appsettings.json' was not found and is not optional. 
    at Microsoft.Extensions.Configuration.FileConfigurationProvider.Load(Boolean reload) 
    at Microsoft.Extensions.Configuration.FileConfigurationProvider.Load() 
    at Microsoft.Extensions.Configuration.ConfigurationRoot..ctor(IList`1 providers) 
    at Microsoft.Extensions.Configuration.ConfigurationBuilder.Build() 
    at Quanta.API.Startup..ctor(IHostingEnvironment env) in D:\Source\Workspaces\Quanta\src\Quanta.API\Startup.cs:line 50 
--- End of stack trace from previous location where exception was thrown --- 
    at System.Runtime.ExceptionServices.ExceptionDispatchInfo.Throw() 
    at Microsoft.Extensions.Internal.ActivatorUtilities.ConstructorMatcher.CreateInstance(IServiceProvider provider) 
    at Microsoft.Extensions.Internal.ActivatorUtilities.CreateInstance(IServiceProvider provider, Type instanceType, Object[] parameters) 
    at Microsoft.Extensions.Internal.ActivatorUtilities.GetServiceOrCreateInstance(IServiceProvider provider, Type type) 
    at Microsoft.Extensions.DependencyInjection.ActivatorUtilities.GetServiceOrCreateInstance(IServiceProvider provider, Type type) 
    at Microsoft.AspNetCore.Hosting.Internal.StartupLoader.LoadMethods(IServiceProvider services, Type startupType, String environmentName) 
    at Microsoft.AspNetCore.Hosting.WebHostBuilderExtensions.<>c__DisplayClass1_0.<UseStartup>b__1(IServiceProvider sp) 
    at Microsoft.Extensions.DependencyInjection.ServiceLookup.FactoryService.Invoke(ServiceProvider provider) 
    at Microsoft.Extensions.DependencyInjection.ServiceProvider.ScopedCallSite.Invoke(ServiceProvider provider) 
    at Microsoft.Extensions.DependencyInjection.ServiceProvider.SingletonCallSite.Invoke(ServiceProvider provider) 
    at Microsoft.Extensions.DependencyInjection.ServiceProvider.<>c__DisplayClass12_0.<RealizeService>b__0(ServiceProvider provider) 
    at Microsoft.Extensions.DependencyInjection.ServiceProvider.GetService(Type serviceType) 
    at Microsoft.Extensions.DependencyInjection.ServiceProviderServiceExtensions.GetRequiredService(IServiceProvider provider, Type serviceType) 
    at Microsoft.Extensions.DependencyInjection.ServiceProviderServiceExtensions.GetRequiredService[T](IServiceProvider provider) 
    at Microsoft.AspNetCore.Hosting.Internal.WebHost.EnsureStartup() 
    at Microsoft.AspNetCore.Hosting.Internal.WebHost.EnsureApplicationServices() 
    at Microsoft.AspNetCore.Hosting.Internal.WebHost.BuildApplication() 
Hosting environment: Production 
Content root path: D:\home\site\wwwroot 
Now listening on: http://localhost:30261 
Application started. Press Ctrl+C to shut down. 

Ok, das einfach zu sein scheint. Es kann appsettings.json nicht finden. Mit Blick auf meine Konfiguration (startup.cs) scheint es sehr gut definiert zu sein. Mein Startup sieht so aus:

public class Startup 
{ 
    private static string _applicationPath = string.Empty; 
    private static string _contentRootPath = string.Empty; 
    public IConfigurationRoot Configuration { get; set; } 
    public Startup(IHostingEnvironment env) 
    { 
     _applicationPath = env.WebRootPath; 
     _contentRootPath = env.ContentRootPath; 
     // Setup configuration sources. 

     var builder = new ConfigurationBuilder() 
      .SetBasePath(_contentRootPath) 
      .AddJsonFile("appsettings.json") 
      .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true); 

     if (env.IsDevelopment()) 
     { 
      // This reads the configuration keys from the secret store. 
      // For more details on using the user secret store see http://go.microsoft.com/fwlink/?LinkID=532709 
      builder.AddUserSecrets(); 
     } 

     builder.AddEnvironmentVariables(); 
     Configuration = builder.Build(); 
    } 
    private string GetXmlCommentsPath() 
    { 
     var app = PlatformServices.Default.Application; 
     return System.IO.Path.Combine(app.ApplicationBasePath, "Quanta.API.xml"); 
    } 

    // This method gets called by the runtime. Use this method to add services to the container. 
    // For more information on how to configure your application, visit http://go.microsoft.com/fwlink/?LinkID=398940 
    public void ConfigureServices(IServiceCollection services) 
    { 
     var pathToDoc = GetXmlCommentsPath(); 


     services.AddDbContext<QuantaContext>(options => 
      options.UseSqlServer(Configuration["Data:DefaultConnection:ConnectionString"], 
      b => b.MigrationsAssembly("Quanta.API"))); 

     //Swagger 
     services.AddSwaggerGen(); 
     services.ConfigureSwaggerGen(options => 
     { 
      options.SingleApiVersion(new Info 
      { 
       Version = "v1", 
       Title = "Project Quanta API", 
       Description = "Quant.API", 
       TermsOfService = "None" 
      }); 
      options.IncludeXmlComments(pathToDoc); 
      options.DescribeAllEnumsAsStrings(); 
     }); 

     // Repositories 
     services.AddScoped<ICheckListRepository, CheckListRepository>(); 
     services.AddScoped<ICheckListItemRepository, CheckListItemRepository>(); 
     services.AddScoped<IClientRepository, ClientRepository>(); 
     services.AddScoped<IDocumentRepository, DocumentRepository>(); 
     services.AddScoped<IDocumentTypeRepository, DocumentTypeRepository>(); 
     services.AddScoped<IProjectRepository, ProjectRepository>(); 
     services.AddScoped<IProtocolRepository, ProtocolRepository>(); 
     services.AddScoped<IReviewRecordRepository, ReviewRecordRepository>(); 
     services.AddScoped<IReviewSetRepository, ReviewSetRepository>(); 
     services.AddScoped<ISiteRepository, SiteRepository>(); 

     // Automapper Configuration 
     AutoMapperConfiguration.Configure(); 

     // Enable Cors 
     services.AddCors(); 

     // Add MVC services to the services container. 
     services.AddMvc() 
      .AddJsonOptions(opts => 
      { 
       // Force Camel Case to JSON 
       opts.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver(); 
      }); 
    } 

    // This method gets called by the runtime. Use this method to configure the HTTP request pipeline. 
    public void Configure(IApplicationBuilder app) 
    { 
     app.UseStaticFiles(); 
     // Add MVC to the request pipeline. 
     app.UseCors(builder => 
      builder.AllowAnyOrigin() 
      .AllowAnyHeader() 
      .AllowAnyMethod()); 

     app.UseExceptionHandler(
      builder => 
      { 
       builder.Run(
       async context => 
       { 
        context.Response.StatusCode = (int)HttpStatusCode.InternalServerError; 
        context.Response.Headers.Add("Access-Control-Allow-Origin", "*"); 

        var error = context.Features.Get<IExceptionHandlerFeature>(); 
        if (error != null) 
        { 
         context.Response.AddApplicationError(error.Error.Message); 
         await context.Response.WriteAsync(error.Error.Message).ConfigureAwait(false); 
        } 
       }); 
      }); 

     app.UseMvc(routes => 
     { 
      routes.MapRoute(
       name: "default", 
       template: "{controller=Home}/{action=Index}/{id?}"); 

      // Uncomment the following line to add a route for porting Web API 2 controllers. 
      //routes.MapWebApiRoute("DefaultApi", "api/{controller}/{id?}"); 
     }); 


     //Ensure DB is created, and latest migration applied. Then seed. 
     using (var serviceScope = app.ApplicationServices 
      .GetRequiredService<IServiceScopeFactory>() 
      .CreateScope()) 
     { 
      QuantaContext dbContext = serviceScope.ServiceProvider.GetService<QuantaContext>(); 
      dbContext.Database.Migrate(); 
      QuantaDbInitializer.Initialize(dbContext); 
     } 


     app.UseSwagger(); 
     app.UseSwaggerUi(); 


    } 
} 

Dies funktioniert gut lokal. Aber sobald wir Azure veröffentlichen, schlägt dies fehl. Ich bin ratlos. Ich habe ein neues .Net-Core-Projekt erstellt, das nur Azure bereitstellen kann. Aber dieses eine Projekt, in das ich all meine Zeit gesteckt habe, scheint zu scheitern. Ich bin bereit, Code aus dem Projekt, das nicht läuft, in ein neues Projekt zu kopieren und einzufügen, aber ich bin wirklich neugierig darauf, was das alles kaputt macht.

Irgendwelche Ideen?

EDIT: Also meine Program.cs war:

using System; 
using System.Collections.Generic; 
using System.IO; 
using System.Linq; 
using System.Threading.Tasks; 
using Microsoft.AspNetCore.Hosting; 

namespace Quanta.API 
{ 
    public class Program 
    { 
     public static void Main(string[] args) 
     { 
      var host = new WebHostBuilder() 
       .UseKestrel() 
       .UseContentRoot(Directory.GetCurrentDirectory()) 
       .UseIISIntegration() 
       .UseStartup<Startup>() 
       .Build(); 

      host.Run(); 
     } 
    } 
} 

Edit2: Per Frans, ich die publishOptions geprüft. Es war:

"publishOptions": { 
"include": [ 
    "wwwroot", 
    "web.config" 
] 

},

ich ein publishOptions von einem Arbeitsprojekt nahm und es änderte

"publishOptions": { 
    "include": [ 
    "wwwroot", 
    "Views", 
    "Areas/**/Views", 
    "appsettings.json", 
    "web.config" 
    ] 
    }, 

Es gab noch einen 500-Fehler ::, aber es gab nicht ein Stack-Trace sagt, dass es appsettings.json laden kann. Jetzt beschwerte er sich über eine Verbindung zu SQL. Ich habe festgestellt, dass mein SQL-Verbindungsstring-Code in vielen RC1-Blog-Posts erwähnt wird. RC2 von .Net Core hat es geändert. So aktualisiert ich es:

"Data": { 
    "ConnectionStrings": { 
     "DefaultConnection": "Server=(localdb)\\MSSQLLocalDB;Database=QuantaDb;Trusted_Connection=True;MultipleActiveResultSets=true" 
    } 
    }, 

Und änderte mein Start:

services.AddDbContext<QuantaContext>(options => 
     options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection"), 
     b => b.MigrationsAssembly("Quanta.API"))); 

Schließlich es funktionierte.

Ich muss ein älteres RC1 Beispiel gefolgt haben und es nicht erkannt haben.

Answer 1

Überprüfen Sie die publishOptions in project.json und stellen Sie sicher, dass der Abschnitt "include" "appsettings.json" enthält. Sie haben das Veröffentlichungsmodell in RTM so geändert, dass Sie alles angeben müssen, was Sie aus dem Kompilierungsverzeichnis in den Webordner kopieren möchten.

Answer 2

In Ihrem project.json

sorgen Sie appsettings.json als copyToOutput

"buildOptions": { 
    "emitEntryPoint": true, 
    "preserveCompilationContext": true, 
    "copyToOutput": { 
    "include": [ "appsettings.json" ] 
    } 
}, 

Answer 3

In späteren .net Core-Versionen ein * CSPROJ Datei verwendet wird anstelle der project.json Datei inlcuded haben .

Sie können die Datei ändern, indem Sie das gewünschte Ergebnis zu erhalten, und fügte hinzu:

<ItemGroup> 
     <Content Update="appsettings.json"> 
     <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory> 
     </Content> 
    </ItemGroup> 

Answer 4

Sie brauchen nicht Ihre .json Datei hinzufügen Optionen zu veröffentlichen. ist es nur, dass es nach der Datei auf dem falschen Pfad sucht.

Basispfad festlegen und dann JSON-Datei hinzufügen und es wird funktionieren.

public Startup(IHostingEnvironment environment) 
    { 
     var builder = new ConfigurationBuilder() 
      .SetBasePath(environment.ContentRootPath) 
      .AddJsonFile("TestJson.json"); 

     Configuration = builder.Build(); 
    } 

hier wird Startup-Konstruktor gebaut mit mit HostingEnviornment und Basispfad wird auf den aktuellen Wurzelpfad festgelegt. und es wird funktionieren!