भाग 1 में, हमने एक मशीन की कुल संरचनाओं का पता लगाया. वेनप्टर निवेदन और प्रतिक्रिया. अब, हम गहरी सतह में कूद देंगे: सर्वर और मेजबानों के साथ गहराई में. यह है जहां सब कुछ शुरू होता है - जहां आपका अनुप्रयोग जीवन के लिए आता है और जहाँ कच्चा नेटवर्क निवेदन किया जाता है संरचना में बदल रहे हैं. HttpContext वस्तुओं जो आपके मध्य ऐंग्रैप के माध्यम से प्रवाहित करते हैं।
इस परत को समझना महत्वपूर्ण है क्योंकि यह नियंत्रण करता है कि कैसे आपका अनुप्रयोग शुरू होता है, और यह किस प्रकार मूल वेब सर्वर के साथ व्यवहार करता है. क्या आप उत्पादन करने के लिए तैनात कर रहे हैं, न्यूनतम रूप से प्रदर्शन, या HTTP प्रवाहित करने के लिए, मेजबानिंग परत जहां इन चिन्ताओं को सम्बोधित किया जाता है.
ध्यान दीजिए: यह एआई / एक तरीका है जो अपने परीक्षणों का हिस्सा है. मैं इस पत्रों, मेरी समझ के कागजों, प्रश्नों को खिलाने के लिए मुझे यह लेख तैयार करना पड़ा है. यह मज़ेदार है और मैं कहीं भी नहीं देखा है.
एनईएस. कोरल अनुप्रयोग होस्टिंग की चिन्ताओं को अलग करता है तथा दो अलग परतों में सेवा करता है:
यह अलग से अलग है: आप कंसोल में अदला बदली कर सकते हैं (Krow, HTTPssss. switations) अपने अनुप्रयोग कोड को बदलने के बिना या अलग मेजबानिंग वातावरण में अपना अनुप्रयोग चलाने के लिए. (कोई समायोजन, विंडोज़ सेवा, तंत्र) सर्वर को संशोधित किए बगैर.
वेन कोर 6 में और बाद में, होस्ट मॉडल को सरल कर दिया गया है WebApplication और WebApplicationBuilder. इसने वृद्ध जनों की जगह ले ली IHostBuilder और IWebHostBuilder एक अधिक धाराित एपीआई के साथ पैटर्न.
// 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(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();
एनईएसई.NT एक जटिल कॉन्फ़िगरेशन तंत्र प्रदान करता है जो बहुत से स्रोतों को आगे बढ़ाता है:
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();
Kestrol है Abl. neck Cont Cons' क्रास-ब्ब्ब्बक वेब सर्वर. यह तेजी से, हल्का है और उत्पादन कार्य लोड करने में सक्षम सक्षम सक्षम है. को समझने की क्षमता आपको अपने अनुप्रयोग के प्रदर्शन और सुरक्षा को कम करने में मदद करती है.
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
बाइट्स कैसे बन जाते हैं यह समझने के लिए कि आपके बीच का कौन - सा संदर्भ इस्तेमाल कर सकता है, यह कोरल के आंतरिक प्रवाह और ज़िम्मेदारियों पर ज़ूम करने में मदद करता है ।
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
देखने हेतु कुंजी:
आप कॉन्फ़िगर कर सकते हैं कि कौन - से अंत - बिन्दु कान सुनते हैं और कैसे:
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();
वैकल्पिक रूप से, आप एग्रेसन के जरिए अंत- बिन्दु कॉन्फ़िगर कर सकते हैं:
{
"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();
ग्रोन अनुप्रयोगों के लिए HTTP आवश्यक है. केआईआरल टीएलएस को कॉन्फ़िगर करने के लिए कई तरीके प्रदान करता है:
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();
केआईआरल रिसोर्स उपयोग को नियंत्रित करने के लिए बहुत सारे विकल्पों को प्रदान करता है:
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();
केआईआरल आधुनिक एचटीटीपी प्रोटोकॉल समर्थित करता है:
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();
केआईआरल सर्वर क्षमताओं को प्रकट करता है 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();
एनईएससी कोरस हैंडल स्वतः बंद कर देता है, लेकिन आप व्यवहार को अनुकूलित कर सकते हैं:
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();
उत्पादन में, केवरल किसी उलटा प्रॉक्सी के पीछे विशेष रूप से रहता है (जाक्स, ft, 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();
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();
var builder = WebApplication.CreateBuilder(args);
// Enable systemd lifetime
builder.Host.UseSystemd();
var app = builder.Build();
app.Run();
जब केस्टल मानक विकल्प है, तब आप आवश्यकता होने पर मनपसंद सर्वर को लागू कर सकते हैं:
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();
HttpContext वस्तु जो मध्य- एलबम के माध्यम से प्रवाहित करती हैIFeatureCollection कम- स्तर सर्वर क्षमता में पहुँच प्रदान करता हैसर्वर तथा होस्टिंग परत को समझने से आप अपने अनुप्रयोग की शुरूआत कैसे होती है यह कनेक्शन को नियंत्रित करता है, और कैसे यह लोड के नीचे काम करता है. यह नींव जो कुछ भी ऊपर होता है उसे समर्थन करता है.
© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.