Κατανοώντας το κύριο αίτημα ASP.NET και τον αγωγό απόκρισης - Μέρος 2: Server και Hosting Layer (ελληνικά (Greek))

Κατανοώντας το κύριο αίτημα ASP.NET και τον αγωγό απόκρισης - Μέρος 2: Server και Hosting Layer

Sunday, 09 November 2025

//

14 minute read

Comments Raw Edit
AI-Article ASP.NET ASP.NET Lifecycle

Εισαγωγή

Στο Μέρος 1, εξερευνήσαμε τη συνολική αρχιτεκτονική του ASP.NET Κεντρικό αίτημα και τον αγωγό απόκρισης. Τώρα, θα βουτήξουμε βαθιά στο θεμέλιο στρώμα: ο διακομιστής και η υποδομή φιλοξενίας. HttpContext αντικείμενα που ρέουν μέσω του μεσαίου σου αγωγού.

Κατανόηση αυτού του στρώματος είναι ζωτικής σημασίας επειδή ελέγχει πώς ξεκινά η εφαρμογή σας, πώς είναι ρυθμισμένο, και πώς αλληλεπιδρά με το υποκείμενο web server. Είτε είστε σε ανάπτυξη στην παραγωγή, βελτιστοποίηση των επιδόσεων, ή τη ρύθμιση HTTPS, το επίπεδο φιλοξενίας είναι όπου αυτές οι ανησυχίες απευθύνονται.

ΣΗΜΕΙΩΣΗ: Αυτό είναι μέρος των πειραμάτων μου με AI / ένας τρόπος για να περάσετε $ 1000 Calude Code Web πιστώσεις. Έχω ταΐσει αυτό ένα BUNCH των εγγράφων, την κατανόησή μου, ερωτήσεις που έπρεπε να δημιουργήσω αυτό το άρθρο. Είναι διασκεδαστικό και γεμίζει ένα κενό που δεν έχω δει πουθενά αλλού.

The Two-Layer Architecture: Host and Server

Το ASP.NET Core χωρίζει τις ανησυχίες της φιλοξενίας εφαρμογών και του διαδικτύου που εξυπηρετούνται σε δύο διαφορετικά στρώματα:

  1. Ο Οικοδεσπότης - Διαχειρίζεται τη διάρκεια ζωής της εφαρμογής, τη διαμόρφωση, την ένεση εξάρτησης, και την καταγραφή
  2. Ο εξυπηρετητής - Χειρίζεται τις επικοινωνίες HTTP, ακούει για αιτήματα, και διαχειρίζεται συνδέσεις

Αυτός ο διαχωρισμός παρέχει ευελιξία: μπορείτε να ανταλλάξετε διακομιστές (Kestrel, HTTP.sys, IIS Integration) χωρίς να αλλάξετε τον κωδικό εφαρμογής σας, ή να εκτελέσετε την εφαρμογή σας σε διαφορετικά περιβάλλοντα φιλοξενίας (console app, Υπηρεσία Windows, systemd daemon) χωρίς τροποποίηση της ρύθμισης του διακομιστή.

The Host Layer

WebApplication και WebApplicationBuilder

Στο ASP.NET Core 6 και αργότερα, το μοντέλο φιλοξενίας έχει απλοποιηθεί με WebApplication και WebApplicationBuilder. Αυτό αντικατέστησε το παλαιότερο IHostBuilder και IWebHostBuilder μοτίβο με ένα πιο εξορθολογισμένο API.

// Modern ASP.NET Core 8 application
var builder = WebApplication.CreateBuilder(args);

// Configure services during the build phase
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

// Build the application
var app = builder.Build();

// Configure middleware after building
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();

// Start the server and begin processing requests
app.Run();

Τι συμβαίνει κατά τη διάρκεια της WebApplication.CreateBuilder();

Όταν τηλεφωνείς WebApplication.CreateBuilder(args), ένα σημαντικό ποσό της αρχικοποίησης συμβαίνει:

// Simplified view of what CreateBuilder does internally
public static WebApplicationBuilder CreateBuilder(string[] args)
{
    var builder = new WebApplicationBuilder();

    // 1. Configure the host defaults
    //    - Content root path (Directory.GetCurrentDirectory())
    //    - Load appsettings.json and appsettings.{Environment}.json
    //    - Load environment variables
    //    - Load command-line arguments
    //    - Setup default logging providers (Console, Debug, EventSource, EventLog on Windows)

    // 2. Configure Kestrel as the default web server
    builder.WebHost.UseKestrel();

    // 3. Setup dependency injection container
    //    - Creates the IServiceCollection
    //    - Registers core services

    // 4. Configure the environment
    //    - Sets ASPNETCORE_ENVIRONMENT (Development, Staging, Production)
    //    - Determines if running in development mode

    // 5. Setup configuration system
    //    - Creates the IConfiguration hierarchy
    //    - Combines all configuration sources

    return builder;
}

Προσαρμογή του υπολογιστή

Έχετε εκτεταμένο έλεγχο σχετικά με το πώς ο υπολογιστής είναι ρυθμισμένος:

var builder = WebApplication.CreateBuilder(args);

// Configure Kestrel server options
builder.WebHost.ConfigureKestrel(serverOptions =>
{
    serverOptions.Limits.MaxConcurrentConnections = 100;
    serverOptions.Limits.MaxRequestBodySize = 10 * 1024 * 1024; // 10 MB
    serverOptions.Limits.MinRequestBodyDataRate = new MinDataRate(
        bytesPerSecond: 100,
        gracePeriod: TimeSpan.FromSeconds(10)
    );
});

// Add additional configuration sources
builder.Configuration.AddJsonFile("customsettings.json", optional: true);
builder.Configuration.AddEnvironmentVariables(prefix: "MYAPP_");

// Configure logging
builder.Logging.ClearProviders(); // Remove defaults
builder.Logging.AddConsole();
builder.Logging.AddDebug();
builder.Logging.SetMinimumLevel(LogLevel.Warning);

// Change the content root and web root
builder.Environment.ContentRootPath = "/custom/path";
builder.Environment.WebRootPath = "/custom/wwwroot";

var app = builder.Build();

Το κοντέινερ υπηρεσίας

Οι υπηρεσίες που είναι καταχωρημένες εδώ είναι διαθέσιμες καθ' όλη τη διάρκεια της εφαρμογής σας:

var builder = WebApplication.CreateBuilder(args);

// Singleton: One instance for the application lifetime
builder.Services.AddSingleton<IMyService, MyService>();

// Scoped: One instance per request
builder.Services.AddScoped<IRequestService, RequestService>();

// Transient: New instance every time it's requested
builder.Services.AddTransient<ITransientService, TransientService>();

// Configure options pattern
builder.Services.Configure<MyOptions>(
    builder.Configuration.GetSection("MyOptions")
);

// Access configuration directly during service registration
var connectionString = builder.Configuration.GetConnectionString("DefaultConnection");
builder.Services.AddDbContext<MyDbContext>(options =>
    options.UseSqlServer(connectionString)
);

var app = builder.Build();

Περιβάλλον και διαμόρφωση

Το ASP.NET Core παρέχει ένα εξελιγμένο σύστημα ρυθμίσεων που συγχωνεύει πολλαπλές πηγές:

var builder = WebApplication.CreateBuilder(args);

// Configuration is loaded in this order (later sources override earlier):
// 1. appsettings.json
// 2. appsettings.{Environment}.json
// 3. User secrets (in Development environment only)
// 4. Environment variables
// 5. Command-line arguments

// Access configuration
var mySetting = builder.Configuration["MySection:MySetting"];
var myValue = builder.Configuration.GetValue<int>("MySection:MyValue");

// Check environment
if (builder.Environment.IsDevelopment())
{
    // Development-specific configuration
    builder.Services.AddDatabaseDeveloperPageExceptionFilter();
}

if (builder.Environment.IsProduction())
{
    // Production-specific configuration
    builder.Configuration.AddAzureKeyVault(/* ... */);
}

var app = builder.Build();

The Server Layer: Kestrel

Kestrel είναι το cross-platform web server του ASP.NET Core. Είναι γρήγορος, ελαφρύς και ικανός να χειριστεί το φόρτο εργασίας της παραγωγής. Κατανόηση των δυνατοτήτων του Kestrel σας βοηθά να βελτιστοποιήσετε την απόδοση και την ασφάλεια της εφαρμογής σας.

Αρχιτεκτονική Kestrel

flowchart TD
  cc[Client Connection]
  ch["Connection Handler Layer<br/>• TLS/SSL Termination (if HTTPS)<br/>• Protocol Negotiation (HTTP/1.1, HTTP/2, HTTP/3)"]
  parser["HTTP Protocol Parser<br/>• Request Line Parsing (Method, Path, Protocol)<br/>• Header Parsing<br/>• Body Reading"]
  ctx["HttpContext Creation<br/>• Creates HttpContext object<br/>• Populates Request properties<br/>• Prepares Response object"]
  pipeline[Middleware Pipeline]

  cc --> ch --> parser --> ctx --> pipeline

Αρχιτεκτονική Kestrel - βαθύτερη κατάδυση

Για να καταλάβετε πώς οι bytes γίνονται ένα HttpContext που μπορείτε να χρησιμοποιήσετε το μεσαίο λογισμικό σας, βοηθά να μεγεθύνετε την εσωτερική ροή και τις ευθύνες του Kestrel.

flowchart LR
  subgraph os[OS / Network Stack]
    net[(TCP/UDP Sockets)]
  end

  subgraph kestrel[Kestrel Server]
    accept["Connection Accept Loop<br/>(.NET Sockets)"]

    subgraph connmw[Per-Connection Middleware]
      tls["TLS Termination / ALPN<br/>(Selects HTTP/1.1 vs HTTP/2 vs HTTP/3)"]
      limits["Connection & Request Limits<br/>(timeouts, sizes, rate limits)"]
      logging[Connection Logging]
    end

    subgraph proto[Protocol Handlers]
      h1["HTTP/1.1 Handler<br/>(keep-alive, chunked, pipelining)"]
      h2["HTTP/2 Handler<br/>(multiplexing, HPACK)"]
      h3["HTTP/3 Handler<br/>(QUIC, QPACK)"]
    end

    subgraph io[High-Perf IO]
      pipes["System.IO.Pipelines<br/>(zero-copy buffers)"]
      parser2[HTTP Parser]
    end

    features["Feature Mapping<br/>(IFeatureCollection)"]
    ctxpool[HttpContext Pool]
    appinvoke[IHttpApplication.ProcessRequestAsync]
  end

  app[Your Middleware Pipeline]

  net --> accept --> connmw --> proto
  proto --> io --> features --> ctxpool --> appinvoke --> app

sequenceDiagram
  autonumber
  participant C as Client
  participant S as Socket
  participant K as Kestrel
  participant P as Protocol Handler
  participant A as App (Middleware)

  C->>S: Connect (TCP/QUIC)
  S->>K: New connection accepted
  K->>K: TLS handshake + ALPN
  K->>P: Select protocol (HTTP/1.1, 2, or 3)
  loop Read/Parse
    P->>P: Read using System.IO.Pipelines
    P->>P: Parse request line/headers/body
  end
  P->>K: Build features + rent HttpContext from pool
  K->>A: ProcessRequestAsync(HttpContext)
  A-->>K: Writes response via Pipes
  K-->>C: Flush/Send response frames
  Note over K,C: Backpressure applied when client is slow

Βασικά εσωτερικά για να ξέρετε:

  • TLS και ALPN επιλογή αποφασίζει ποιος χειριστής πρωτοκόλλου τρέχει για αυτή τη σύνδεση.
  • Σύστημα.IO.Pipelines υποστηρίζει όλες τις αναλύσεις και τη συγγραφή για τις ελάχιστες πιστώσεις και υψηλή απόδοση.
  • Η χαρτογράφηση χαρακτηριστικών (IfeatureCollection) εκθέτει τις δυνατότητες χαμηλού επιπέδου διακομιστή στο HttpContext χωρίς να το συνδέσει με τους τύπους Kestrel.
  • Τα αντικείμενα HttpContex είναι συγκεντρωμένα για να μειώσουν την πίεση GC.
  • Η πίσω πίεση εφαρμόζεται μέσω των σωλήνων όταν ο πελάτης μπορεί να διαβάσει αρκετά γρήγορα; ο διακομιστής κέρδισε over-buffer γράφει.
  • Χρονικά διαστήματα και όρια (συνέχισε να ζεις, κεφαλίδες, ζήτησε μέγεθος σώματος, όρια ροής HTTP/2) προστατεύουν τον διακομιστή από τα slowloris και την εξάντληση πόρων.
  • ThreadPool: οι περισσότερες εργασίες τρέχει στο ThreadPool; πρωτοκόλλου χειριστές αποφεύγουν τη δημιουργία ανά αίτημα νήμα και την εύνοια async συνεχίζει.

Ρύθμιση των τελικών σημείων του Kestrel

Μπορείτε να ρυθμίσετε ποια τελικά σημεία του Kestrel ακούει και πώς:

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(options =>
{
    // Listen on all network interfaces on port 5000 (HTTP)
    options.Listen(IPAddress.Any, 5000);

    // Listen on localhost port 5001 (HTTPS)
    options.Listen(IPAddress.Loopback, 5001, listenOptions =>
    {
        listenOptions.UseHttps("certificate.pfx", "password");
    });

    // Listen on specific IP with HTTP/2
    options.Listen(IPAddress.Parse("192.168.1.100"), 5002, listenOptions =>
    {
        listenOptions.Protocols = HttpProtocols.Http2;
    });

    // Unix domain socket (Linux/macOS)
    options.ListenUnixSocket("/tmp/myapp.sock");

    // Named pipe (Windows)
    options.ListenNamedPipe("mypipename");
});

var app = builder.Build();

Εναλλακτικά, μπορείτε να ρυθμίσετε τα τελικά σημεία μέσω των ρυθμίσεων.json:

{
  "Kestrel": {
    "Endpoints": {
      "Http": {
        "Url": "http://localhost:5000"
      },
      "Https": {
        "Url": "https://localhost:5001",
        "Certificate": {
          "Path": "certificate.pfx",
          "Password": "your-password"
        }
      }
    }
  }
}

var builder = WebApplication.CreateBuilder(args);

// Endpoints are automatically configured from appsettings.json
// when you don't explicitly call ConfigureKestrel

var app = builder.Build();

Ρύθμιση HTTPS

HTTPS είναι απαραίτητη για εφαρμογές παραγωγής. Kestrel παρέχει διάφορους τρόπους για να ρυθμίσετε TLS:

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(options =>
{
    options.Listen(IPAddress.Any, 5001, listenOptions =>
    {
        // Option 1: Certificate from file
        listenOptions.UseHttps("certificate.pfx", "password");

        // Option 2: Certificate from store (Windows)
        listenOptions.UseHttps(storeCert =>
        {
            storeCert.Subject = "localhost";
            storeCert.Store = "My";
            storeCert.Location = StoreLocation.CurrentUser;
            storeCert.AllowInvalid = false; // Don't allow invalid certs
        });

        // Option 3: Development certificate
        listenOptions.UseHttps(); // Uses development certificate in Development environment

        // Option 4: Configure TLS details
        listenOptions.UseHttps(httpsOptions =>
        {
            httpsOptions.ServerCertificate = LoadCertificate();
            httpsOptions.ClientCertificateMode = ClientCertificateMode.RequireCertificate;
            httpsOptions.CheckCertificateRevocation = true;
            httpsOptions.SslProtocols = SslProtocols.Tls12 | SslProtocols.Tls13;

            // Client certificate validation
            httpsOptions.ClientCertificateValidation = (certificate, chain, errors) =>
            {
                // Custom validation logic
                return errors == SslPolicyErrors.None;
            };
        });
    });
});

var app = builder.Build();

Όρια Kestrel και συντονισμός επιδόσεων

Το Kestrel παρέχει πολλές επιλογές για τον έλεγχο της χρήσης πόρων και τη βελτιστοποίηση της απόδοσης:

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(options =>
{
    // Connection limits
    options.Limits.MaxConcurrentConnections = 100;
    options.Limits.MaxConcurrentUpgradedConnections = 100;

    // Request limits
    options.Limits.MaxRequestBodySize = 10 * 1024 * 1024; // 10 MB
    options.Limits.MaxRequestHeaderCount = 100;
    options.Limits.MaxRequestHeadersTotalSize = 32 * 1024; // 32 KB
    options.Limits.MaxRequestLineSize = 8 * 1024; // 8 KB

    // Keep-alive timeout
    options.Limits.KeepAliveTimeout = TimeSpan.FromMinutes(2);

    // Request header read timeout
    options.Limits.RequestHeadersTimeout = TimeSpan.FromSeconds(30);

    // Minimum data rate for request body
    options.Limits.MinRequestBodyDataRate = new MinDataRate(
        bytesPerSecond: 240,
        gracePeriod: TimeSpan.FromSeconds(5)
    );

    // Minimum data rate for response body
    options.Limits.MinResponseDataRate = new MinDataRate(
        bytesPerSecond: 240,
        gracePeriod: TimeSpan.FromSeconds(5)
    );

    // HTTP/2 specific limits
    options.Limits.Http2.MaxStreamsPerConnection = 100;
    options.Limits.Http2.HeaderTableSize = 4096;
    options.Limits.Http2.MaxFrameSize = 16 * 1024; // 16 KB
    options.Limits.Http2.MaxRequestHeaderFieldSize = 8 * 1024; // 8 KB
    options.Limits.Http2.InitialConnectionWindowSize = 128 * 1024; // 128 KB
    options.Limits.Http2.InitialStreamWindowSize = 96 * 1024; // 96 KB
});

var app = builder.Build();

Υποστήριξη HTTP/2 και HTTP/3

Το Kestrel υποστηρίζει τα σύγχρονα πρωτόκολλα HTTP:

var builder = WebApplication.CreateBuilder(args);

builder.WebHost.ConfigureKestrel(options =>
{
    // HTTP/1.1 only
    options.Listen(IPAddress.Any, 5000, listenOptions =>
    {
        listenOptions.Protocols = HttpProtocols.Http1;
    });

    // HTTP/1.1 and HTTP/2
    options.Listen(IPAddress.Any, 5001, listenOptions =>
    {
        listenOptions.Protocols = HttpProtocols.Http1AndHttp2;
        listenOptions.UseHttps();
    });

    // HTTP/2 only
    options.Listen(IPAddress.Any, 5002, listenOptions =>
    {
        listenOptions.Protocols = HttpProtocols.Http2;
        listenOptions.UseHttps();
    });

    // HTTP/3 (QUIC) - requires .NET 7+
    options.Listen(IPAddress.Any, 5003, listenOptions =>
    {
        listenOptions.Protocols = HttpProtocols.Http1AndHttp2AndHttp3;
        listenOptions.UseHttps();
    });
});

var app = builder.Build();

Χαρακτηριστικά του εξυπηρετητή

Kestrel εκθέτει τις δυνατότητες διακομιστή μέσω του IFeatureCollection Διατίθεται στις HttpContext:

app.Use(async (context, next) =>
{
    // Check if HTTP/2 is being used
    var http2Feature = context.Features.Get<IHttpRequestFeature>();
    if (http2Feature?.Protocol == "HTTP/2")
    {
        Console.WriteLine("Using HTTP/2");
    }

    // Access connection features
    var connectionFeature = context.Features.Get<IHttpConnectionFeature>();
    Console.WriteLine($"Remote IP: {connectionFeature?.RemoteIpAddress}");
    Console.WriteLine($"Local IP: {connectionFeature?.LocalIpAddress}");

    // TLS information
    var tlsFeature = context.Features.Get<ITlsConnectionFeature>();
    if (tlsFeature?.ClientCertificate != null)
    {
        Console.WriteLine($"Client cert: {tlsFeature.ClientCertificate.Subject}");
    }

    // Request body pipe for high-performance scenarios
    var bodyPipeFeature = context.Features.Get<IRequestBodyPipeFeature>();
    if (bodyPipeFeature != null)
    {
        var reader = bodyPipeFeature.Reader;
        // Use System.IO.Pipelines for zero-copy reads
    }

    await next(context);
});

Εφαρμογή Γεγονότα Διάρκειας Ζωής

Ο ξενιστής παρέχει άγκιστρα για εκδηλώσεις κύκλου εφαρμογής:

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

// Get the application lifetime
var lifetime = app.Services.GetRequiredService<IHostApplicationLifetime>();

// Application started event
lifetime.ApplicationStarted.Register(() =>
{
    Console.WriteLine("Application has started");
    // Perform startup tasks (warm up caches, etc.)
});

// Application stopping event
lifetime.ApplicationStopping.Register(() =>
{
    Console.WriteLine("Application is stopping");
    // Begin graceful shutdown (stop accepting new requests)
});

// Application stopped event
lifetime.ApplicationStopped.Register(() =>
{
    Console.WriteLine("Application has stopped");
    // Cleanup resources
});

app.Run();

Μπορείτε επίσης να εφαρμόσετε IHostedService για τα βασικά καθήκοντα:

public class MyBackgroundService : IHostedService, IDisposable
{
    private Timer? _timer;
    private readonly ILogger<MyBackgroundService> _logger;

    public MyBackgroundService(ILogger<MyBackgroundService> logger)
    {
        _logger = logger;
    }

    public Task StartAsync(CancellationToken cancellationToken)
    {
        _logger.LogInformation("Background service is starting");

        _timer = new Timer(DoWork, null, TimeSpan.Zero, TimeSpan.FromMinutes(5));

        return Task.CompletedTask;
    }

    private void DoWork(object? state)
    {
        _logger.LogInformation("Background service is working");
        // Perform periodic work
    }

    public Task StopAsync(CancellationToken cancellationToken)
    {
        _logger.LogInformation("Background service is stopping");

        _timer?.Change(Timeout.Infinite, 0);

        return Task.CompletedTask;
    }

    public void Dispose()
    {
        _timer?.Dispose();
    }
}

// Register the service
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddHostedService<MyBackgroundService>();
var app = builder.Build();

Ευγενικό Κλείσιμο

ASP.NET Core χειρίζεται χαριτωμένο κλείσιμο αυτόματα, αλλά μπορείτε να προσαρμόσετε τη συμπεριφορά:

var builder = WebApplication.CreateBuilder(args);

// Configure shutdown timeout
builder.WebHost.ConfigureKestrel(options =>
{
    options.AddServerHeader = false; // Remove Server header for security
});

builder.Host.ConfigureHostOptions(options =>
{
    // How long to wait for the application to shut down gracefully
    options.ShutdownTimeout = TimeSpan.FromSeconds(30);
});

var app = builder.Build();

// During shutdown, Kestrel:
// 1. Stops accepting new connections
// 2. Waits for existing requests to complete (up to ShutdownTimeout)
// 3. Aborts remaining requests
// 4. Disposes services
// 5. Runs ApplicationStopped callbacks

app.Run();

Σενάρια Φιλοξενίας Παραγωγής

Τρέξιμο Πίσω από μια Αντίστροφη Προξία

Στην παραγωγή, Kestrel είναι συνήθως πίσω από ένα αντίστροφο διαμεσολαβητή (nginx, Apache, IIS):

var builder = WebApplication.CreateBuilder(args);

// Configure forwarded headers for reverse proxy scenarios
builder.Services.Configure<ForwardedHeadersOptions>(options =>
{
    options.ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto;

    // If your proxy is on a known network
    options.KnownNetworks.Add(new IPNetwork(IPAddress.Parse("10.0.0.0"), 8));
    options.KnownProxies.Add(IPAddress.Parse("10.0.0.1"));

    // Required when running in containers/Kubernetes
    options.ForwardedHeaders = ForwardedHeaders.All;
    options.KnownNetworks.Clear();
    options.KnownProxies.Clear();
});

var app = builder.Build();

// Must be before other middleware
app.UseForwardedHeaders();

app.UseHttpsRedirection();
app.UseAuthentication();
app.UseAuthorization();

app.MapControllers();

app.Run();

Φιλοξενία υπηρεσιών Windows

var builder = WebApplication.CreateBuilder(args);

// Enable Windows Service lifetime
builder.Host.UseWindowsService();

// Configure content root for Windows Service
builder.Host.UseContentRoot(AppContext.BaseDirectory);

var app = builder.Build();

app.Run();

Linux systemd Service Hosting

var builder = WebApplication.CreateBuilder(args);

// Enable systemd lifetime
builder.Host.UseSystemd();

var app = builder.Build();

app.Run();

Προχωρημένος: Προσαρμοσμένος εξυπηρετητής

Ενώ Kestrel είναι η τυπική επιλογή, μπορείτε να εφαρμόσετε ένα προσαρμοσμένο διακομιστή, αν χρειάζεται:

public class CustomServer : IServer
{
    private IFeatureCollection _features = new FeatureCollection();

    public IFeatureCollection Features => _features;

    public Task StartAsync<TContext>(IHttpApplication<TContext> application,
        CancellationToken cancellationToken) where TContext : notnull
    {
        // Start listening for connections
        // Create HttpContext for each request
        // Invoke application.ProcessRequestAsync(httpContext)
        return Task.CompletedTask;
    }

    public Task StopAsync(CancellationToken cancellationToken)
    {
        // Stop accepting new connections
        // Wait for existing requests to complete
        return Task.CompletedTask;
    }

    public void Dispose()
    {
        // Cleanup resources
    }
}

// Use custom server
var builder = WebApplication.CreateBuilder(args);
builder.WebHost.UseServer(new CustomServer());
var app = builder.Build();

Απομακρύνσεις κλειδιών@ title: window

  • Ο οικοδεσπότης διαχειρίζεται τη διάρκεια ζωής της εφαρμογής, τη διαμόρφωση, DI, και την καταγραφή
  • Kestrel είναι ένα υψηλής απόδοσης, cross-platform web server
  • Μπορείτε να ρυθμίσετε τελικά σημεία, HTTPS, πρωτόκολλα και όρια απόδοσης
  • Ο διακομιστής δημιουργεί HttpContext αντικείμενα που ρέουν μέσω του αγωγού μεσαίου λογισμικού
  • Το χαριτωμένο κλείσιμο εξασφαλίζει την ολοκλήρωση των αιτήσεων πριν από τη λήξη της εφαρμογής
  • Οι εφαρμογές παραγωγής χρησιμοποιούν συνήθως το Kestrel πίσω από ένα αντίστροφο διαμεσολαβητή
  • Η IFeatureCollection παρέχει πρόσβαση σε δυνατότητες διακομιστή χαμηλού επιπέδου

Κατανόηση του διακομιστή και το στρώμα φιλοξενίας σας δίνει τον έλεγχο πάνω στο πώς ξεκινά η εφαρμογή σας, πώς χειρίζεται τις συνδέσεις, και πώς εκτελεί υπό φορτίο.

Finding related posts...
logo

© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.