Open IIS by typing “inetmgr” in the Run window and clicking OK as shown in the following image.

This will open the IIS window.
For the application you wish to terminate, create a new application pool. As seen in the accompanying figure, right-click on Application Pool and choose New -> Application Pool.

As seen in the accompanying screenshot, give your application pool the proper name and leave the other options in the window as they are. Press OK.

As seen in the accompanying graphic, your application pool will now be created. As you can see, there are no applications associated with this recently established application pool. View the side on the right. "There are no items to shown in this view," is what is displayed.

It is now necessary to link the application you wish to terminate with this recently established application pool.
Choose the program that you wish to terminate. Use a right-click to choose Properties. View the picture below. As seen in the accompanying image, the window that follows will open.

Click on the Create button.
Automatically Application Name will be enabled by IIS and it is the name of the application by default for which you are doing this activity. You can change it as you prefer. Also, the Application Pool dropdown is now enabled.
Now select the Application Pool that you created earlier from the Application Pool dropdown list as shown in the following image.

Click OK.
Now to stop that only application, right-click on the Application Pool name then select Stop as shown in the following image.

To start the application, right-click on the Application Pool name then select Start. In this way, you can start and stop only one application under IPlanetWebsite in which many applications are deployed under it.

We will learn how to host a mobile website under Internet Information Services (IIS) in this tutorial. We must first develop a mobile web application. See my earlier post, "Developing Mobile Pages," for information on how to make a mobile website.

Testing mobile pages is not as simple as it may seem once they have been produced; mobile emulators and desktop browsers can both be used for this purpose. You can test using a direct debugging program in desktop browsers, but on mobile emulators, we must first host our website under IIS. I'll go over how to test mobile pages in mobile emulators in my upcoming article. The next article requires reading this one first. We must first host the website under IIS in order to test mobile pages in an emulator.
website hosting

To assist you in hosting the website on IIS, take a look at the screenshot below.

Launch the IIS Manager.

To access the virtual directory, right-click on Default Web Site, select New, and the screen that follows will display.

Enter the virtual name you want people to use to access your website when they type the URL. then select "Next."
You will be prompted to submit the application's physical content on the next screen.

You will be prompted to adjust your website's authorization settings on the following screen. After making all permission selections, click Next, followed by Finish.

Your website is built once the creation process is complete.

Now test whether your website is working or not. To do that open your browser and type the url like below or you can type your IP address also instead of localhost.

There are a few tricks involved in deploying React on Internet Information Service.

Installing the rewrite module on Windows, configuring the IIS pool, selecting the port to run your React project on, copying the web.config, and setting up your project in an Index.html file are all necessary.

The steps to help you are as follows.
Now let's get going.

These two scripts should be added to the end of the body of your React project's Index.html in the public folder.

<script src="https://unpkg.com/react@18/umd/react.development.js" crossorigin></script>
<script src="https://unpkg.com/react-dom@18/umd/react-dom.development.js" crossorigin></script>

When the code is published for production, please alter the .development.js to .production.min.js.
On your project, run the build command.
npm run build

Copy the files from the build folder to your IIS target folder.
Add this web. config in the target folder under IIS.
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <system.webServer>
        <rewrite>
            <rules>
               <rule name="Static Assets" stopProcessing="true">
                    <match url="([\S]+[.](html|htm|svg|js|css|png|gif|jpg|jpeg))" />
                    <action type="Rewrite" url="/{R:1}"/>
                </rule>
                <rule name="ReactRouter Routes" stopProcessing="true">
                    <match url=".*" />
                    <conditions logicalGrouping="MatchAll">
                        <add input="{REQUEST_FILENAME}" matchType="IsFile" negate="true" />
                        <add input="{REQUEST_FILENAME}" matchType="IsDirectory" negate="true" />
                    </conditions>
                    <action type="Rewrite" url="/index.html" />
                </rule>
            </rules>
        </rewrite>
    </system.webServer>
</configuration>

To make it work, you must install a rewrite module if you haven't it.
https://www.iis.net/downloads/microsoft/url-rewrite, choose your language, download, and install it.
Adjust the pool

Adjust your binds and default port.
Choose Bindings, and click on Edit.
Choose a Port for your React app to work.

Now, you must have your first React app on IIS working. Good lucky!

Sometimes we receive this error message after publishing the solution in IIS. This mistake is very common.

Exact Error
Error message 401.2: Unauthorized The login failed due to server configuration. Check that you have authorization to browse this directory or page using the credentials you provided and the authentication methods enabled on the Web server. For further assistance, contact the web server administrator.

This problem is mostly caused by IIS's authentication settings.

Solution
Launch the IIS.

Choose the site where you are experiencing the problem.
Select Authentication. Setting as indicated.

Authentication choices can be updated based on your application's requirements.

In my case, the application needs to set windows authentication, therefore, I set it to enabled and Anonymous Authentication Disabled.

First, let me explain the problem I encountered in the web forms application (ASPX). I have a legacy web application that was created in ASP.NET and deployed on IIS 10. Static files (PDF, JS, CSS, JSON, and all forms of pictures (jpg, png, BMP, etc.)) are stored in a subfolder on the site called data, such as http://example.com/data/...When an unauthenticated person browses the files.

e.g.

http://example.com/data/image.gif or http://example.com/data/sample.css or http://example.com/data/sample.js).
It will display the files without authentication. In other words, the pages should only be accessible once the user is authorized.

IIS Default Behavior By default, the IIS web server routes ASP.NET resource requests to the ASP.NET runtime, but it handles static content requests directly. As a result, requests for static content are served without consideration for the URL authorization requirements specified in the ASP.NET application settings.

When I try to browse this issues regarding the same in internet , there are lot of things like enabling runAllManagedModulesForAllRequests="true" but nothings works out. Even though I am running my application in integrated mode in IIS.

Then I came to know about HTTPHandler. Below is the definition of HTTP Handler from Microsoft.

HTTP modules and HTTP handlers are an integral part of the ASP.NET architecture. While a request is being processed, each request is processed by multiple HTTP modules (for example, the authentication module and the session module) and is then processed by a single HTTP handler. After the handler has processed the request, the request flows back through the HTTP modules.

HTTPHandlers are used by ASP.NET web application server to handle specific requests based on extensions. HTTPHandlers run as processes in response to a request made to the ASP.NET website. It is a class that implements the System.
How to implement HTTPHandler to handle any incoming HTTP request with a path like .gif/.js/.css?

• Create a class file — it could be FileProtectionHandler.cs
• Let FileProtectionHandler class inherit from IhttpHandler Interface.
• In FileProtectionHandler class, implement all the methods which are found in IhttpHandler Interface.

When a request comes, it will check whether it will be authenticated or not, if not it will redirect to login page otherwise will send the requested file based on the file extension.
using System;
using System.IO;
using System.Web;
namespace Example.UI {
    public class FileProtectionHandler: IHttpHandler {
        /// <summary>
        /// You will need to configure this handler in the Web.config file of your
        /// web and register it with IIS before being able to use it. For more information
        /// see the following link: https://go.microsoft.com/?linkid=8101007
        /// </summary>
        #region IHttpHandler Members
        public bool IsReusable {
            // Return false in case your Managed Handler cannot be reused for another request.
            // Usually this would be false in case you have some state information preserved per request.
            get {
                return true;
            }
        }
        public void ProcessRequest(HttpContext context) {
            //write your handler implementation here.
            if (!context.User.Identity.IsAuthenticated) {
                context.Response.Redirect("~/Login.aspx");
                return;
            } else {
                string requestedFile = context.Server.MapPath(context.Request.FilePath);
                SendContentTypeAndFile(context, requestedFile);
            }
        }
        private HttpContext SendContentTypeAndFile(HttpContext context, string strFile) {
            context.Response.ContentType = GetContentType(strFile);
            context.Response.TransmitFile(strFile);
            context.Response.End();
            return context;
        }
        private string GetContentType(string fileName) {
            string res = null;
            FileInfo fileInfo = new FileInfo(fileName);
            if (fileInfo.Exists) {
                switch (fileInfo.Extension.Remove(0, 1).ToLower()) {
                    case "pdf": {
                        res = "application/pdf";
                        break;
                    }
                    case "gif": {
                        res = "image/gif";
                        break;
                    }
                }
            }
            return res;
        }
        #endregion
    }
}

The next step is to register the HTTP handler in the Web.config file. Based on your IIS version, it should be added as a child of <system.web> or <system.webServer>. Refer here to register
<httpHandlers>
    <add path="*.gif" verb="*" type="MyProject.FileProtectionHandler" validate="false" />
    <add path="*.png" verb="*" type="MyProject.FileProtectionHandler" validate="false" />
    <add path="*.jpg" verb="*" type="MyProject.FileProtectionHandler" validate="false" />
    <add path="*.js" verb="*" type="MyProject.FileProtectionHandler" validate="false" />
    <add path="*.svg" verb="*" type="MyProject.FileProtectionHandler" validate="false" />
    <add path="*.bmp" verb="*" type="MyProject.FileProtectionHandler" validate="false" />
    <add path="*.json" verb="*" type="MyProject.FileProtectionHandler" validate="false" />
    <add path="*.css" verb="*" type="MyProject.FileProtectionHandler" validate="false" />
</httpHandlers>

That’s all. Now HTTP Handler is ready
Once this configuration information has been specified in Web.config revisit the image file hosted via IIS from your browser. This time while processing the request for the image file IIS allows for the ASP.NET runtime to perform authentication and authorization logic. The ASP.NET runtime notes that the request is coming from an anonymous user and is for a URL that denies anonymous users. Therefore, the anonymous user is redirected to the login page, just like when visiting the image file served by the ASP.NET Development Server.

A user's request does not go to the database every time they visit a website in order to answer every detail. As an alternative, some data is extracted directly, which speeds up and improves efficiency. This tactic enables the server to process numerous requests from various users without interfering with the database. Important information is stored in the server's memory so that it can respond to your request promptly.

Given that data is typically saved in databases, you may be asking how the server obtains, stores, and locates this data.

Thus, the Internet Information Services, or IIS, serves as the operation's beating heart.

Output Caching is the name of the operation.

Even the type of file and duration of storage are customizable. by using the easy steps listed below.

• On your server, open the Internet Information Services (IIS) Manager.
• Access your web application by navigating through the Connections pane.
• Give the "Output Caching" feature a double-click.
• Examine the cached items, their expiration dates, and other pertinent details in the "Output Caching" feature.

But how can the cache be kept there?
Installing System is hence the first step.Net.Caching from the Nuget bundle

Caching in System.Web
You can implement caching within a server-side web application, usually hosted by Internet Information Services (IIS), by using the classes provided by the System.Web.Caching namespace. The caching method uses the server's RAM to cache data when you use the System.Web.Caching namespace in an ASP.NET web application hosted on Internet Information Services (IIS).

Create
HttpRuntime.Cache.Insert("yourkey","your value");To do CRUD activities with such caches, there are a few methods under this namespace.

This is how the cache is set. You might have noticed, though, that the code above doesn't indicate when this caching item expires. This suggests that unless the web application is terminated or restarted, the caching item won't be destroyed. As a result, you must also include an expiration.

Here's another method to get there:

HttpRuntime.Cache.Insert(
     string key,
     object value,
     System.Web.Caching.CacheDependency dependencies,
     DateTime absoluteExpiration,
     TimeSpan slidingExpiration
);

You are aware of the value and key in this case, but what about the other parameters?

Dependencies: When any of a cache item's dependencies are altered or eliminated, the cache item will be automatically cleared.

Nonetheless, if you would like it to stay in the cache until further specified expiration conditions (such absolute or sliding expiration) are satisfied or until it is manually deleted.

Absolute Expiration: The cache can have a precise expiration time that you specify. To set its value, there are three options:

• Absolute Time of Expiration: AbsoluteTime belongs to the DateTime type. You designate a precise day and time for the cache item to expire. The cache expires when this date and time are reached.
• Save.NoAbsoluteExpiration: This constant value means that the item will stay in the cache until it is manually removed, and it does not have an absolute expiration period.
• Blending using Adaptive Expiration:  The slidingExpiration parameter needs to be set to NoSlidingExpiration if you are utilizing absolute expiration.

Declining Expiration
1. Sliding Expiration makes sure that the cache item lifespan will be increased by the interval value if the data is accessed within the designated time frame. For instance, a session with a 10-minute expiration is introduced.
TimeSpan.FromMinutes(5), TimeSpan.FromSeconds(30), NoSlidingExpiration, etc. are few examples.

2. Combining with AbsoluteExpiration: NoAbsoluteExpiration is required as the absolute expiration argument if sliding expiration is being used.

Start Visual Studio: Open the Visual Studio project or solution that is associated with your IIS website.

Configure IIS: Verify that your IIS website is set up and operational. If not, set it up by making a fresh website or utilizing an already-existing one.
Build Configuration: Verify that the configuration for your project contains debugging details. Usually, the "Debug" setting would be utilized.
Begin debugging: Click on the "Start Debugging" button in Visual Studio (or press `F5`). This will connect the debugger and start your application.
Attach to Process: To attach the debugger to an already-running IIS website, go to the "Debug" menu, pick "Attach to Process," and select the process that corresponds to your IIS application pool (in most cases, `w3wp.exe} for IIS worker processes).
Choose the Appropriate Code: Verify that the source code you wish to debug is the same one that IIS is using. Make sure the right project and build configuration are chosen by checking the configuration of the solution.
Establish Breakpoints: Whenever you want the debugger to pause so you may walk through the code and examine variables, place breakpoints in your code.
Debugging: You can now debug your IIS website once it has been attached. At the breakpoints, Visual Studio will pause, allowing you to step through code, examine variables, and troubleshoot problems with the debugging tools.

Keep in mind that in order to attach the debugger to the IIS process and adjust the IIS application pool settings appropriately, you should have the required permissions for efficient debugging.

You should be able to connect the Visual Studio debugger to your IIS website in order to debug it by following these instructions.

Overview
In this post, I'll walk you through the process of installing the file server resource manager correctly and quickly.

Prior to proceeding, let us clarify what file server resource manager is. It is a Windows Server role service that helps you organize and manage data kept on file servers. You can use FSRM to automatically classify files, perform tasks based on these classifications, set quotas on folders, and create reports monitoring storage usage.

The File Server Resource Manager (FSRM) should be installed first. In your sever dashboard click "add roles and features".

Step 4. Click "next".

Step 5. Click the "file and storage" arrow mark and again click the "file and iSCSI" arrow mark. After that, select "file server resource manager".

Step 6. Once you click "file server resource manager" you will see the message in this step click "add features".

Step 7. Click "next".

Step 8. Click "next".

Step 9. Click the "restart" option, and then you will get the warring message. After that click "yes" and then click "install".

Step 10. After that, you can see the installed wizard.

Conclusion
In this article, we all clearly understand how to install the file server resource manager in a proper method. If there is clarification regarding this topic, feel free to contact me.

Today's article will teach you how to uninstall Internet Information Services 8 (IIS8) from Windows Server 2012.

Step 1
To begin, enter your password into your Windows Server 2012 as Administrator. If your Server Manager does not launch automatically after logging in, open it by clicking the first button in the task bar.

When you launch the Server Manager, the following window will appear:

Step 2
On the Server manager you will see that IIS is already installed.

To remove the IIS go to the Manage option on the upper right hand corner and click on "Remove Rolls and Features".

Step 3
Now a Window will be opened that will inform you that you are going to removing the section. Just click on "Next" to proceed.

After that you must select a Server from the Server Pool. Since I have only one Server in this article, my default Server is Automatically selected.

Step 4
Once you click Next you will get a list (Rolls) from which click on the Web Server (IIS).

Now click "Next", then one more Window will open that will ask for permission to remove the features.

Step 5
You can select the features that are associated with IIS to be removed.

After clicking Next you must give permission to restart the server automatically if it's considered necessary, then click on "Next".

Step 6
Click on the "Remove" button and the process will begin.

When the removal process is complete, your Windows Server 2012 will be restarted because you already granted permission to do so.

Step 7
After restarting it will automatically show that the removal process had completed successfully.

You can also check this on the Flag that is present on the above right hand corner. Click on the Flag and following confirmation will be shown,

In this post, we will look at how to use a C# console application to create an IIS website and accompanying application pool programmatically. These tasks are typically performed by an IIS administrator.

We can use this application to automate those tasks. In Visual Studio 2010, construct a console application named IISAutomation and target.NET 3.5, as seen below.

Add a reference to Microsoft.Web.Administration, which may be found at C:WindowsSystem32inetsrv [IIS installation directory]. This assembly contains classes that can be used by a developer to administer the IIS Manager. First, we'll build an application pool with the code below:

private static void CreateAppPool(string pool name,bool enable32bitOn64, ManagedPipelineMode mode,string runtimeVersion="v4.0")
{
    using (ServerManager serverManager = new ServerManager())
    {
        ApplicationPool newPool = serverManager.ApplicationPools.Add(poolname);
        newPool.ManagedRuntimeVersion = runtimeVersion;
        newPool.Enable32BitAppOnWin64 = true;
        newPool.ManagedPipelineMode = mode;
        serverManager.CommitChanges();
    }
}

Here, we created an application pool by creating an instance of the application pool object. Then, we set the properties of the application pool, like the name, the .NET version to be used, and the committed changes by calling CommitChanges(). Similarly, we will create a website using the following code:
private static void CreateIISWebsite(string website name, string hostname, string phyPath, string app pool)
{
    ServerManager iisManager = new ServerManager();
    iisManager.Sites.Add(websiteName, "http", "*:80:" + hostname, phyPath);
    iisManager.Sites[websiteName].ApplicationDefaults.ApplicationPoolName = appPool;

    foreach (var item in iisManager.Sites[websiteName].Applications)
    {
        item.ApplicationPoolName = appPool;
    }

    iisManager.CommitChanges();
}

Here, we created a new website by creating an instance of ServerManager, adding it to the Sites collection setting its properties like name, physical path, and so on and committed the changes.

We will use the preceding methods in our Main method and create an application pool and a website using the following code:

static void Main(string[] args)
{
    Console.WriteLine("Do you want to create an Application Pool:y/n");
    string response = Console.ReadLine();
    if (response.ToString() == "y")
    {
        Console.Write("Please enter Application Pool Name:");
        string poolname = Console.ReadLine();
        bool isEnable32bit = false;
        ManagedPipelineMode mode = ManagedPipelineMode.Classic;
        Console.Write("Need to enable 32 bit on Windows 64 bit?y/n [Applicable for 64 bit OS]: y/n?");
        string enable32bit = Console.ReadLine();
        if (enable32bit.ToLower() == "y")
        {
            isEnable32bit = true;
        }
        Console.Write("Please select Pipeline Mode: 1 for Classic, 2 for Integrated:");
        string pipelinemode = Console.ReadLine();
        if (pipelinemode.ToLower() == "2")
        {
            mode = ManagedPipelineMode.Integrated;
        }
        Console.Write("Please select Runtime Version for Application Pool: 1 for v2.0, 2 for v4.0:");
        string runtimeVersion = Console.ReadLine()== "1" ? "v2.0" : "v4.0";

        CreateAppPool(poolname, isEnable32bit, mode, runtimeVersion);
        Console.WriteLine("Application Pool created successfully...");
    }
                Console.WriteLine("Do you want to create a website:y/n");
    response = Console.ReadLine();
    if (response.ToString() == "y")
    {
        Console.Write("Please enter website name:");
        string websiteName = Console.ReadLine();
        Console.Write("Please enter host name:");
        string hostname = Console.ReadLine();
        Console.Write("Please enter physical path to point for website:");
        string phypath = Console.ReadLine();
        Console.WriteLine("Please enter Application pool Name:");
        foreach(var pool in new ServerManager().ApplicationPools)
        {
            Console.WriteLine(pool.Name);
        }
        Console.WriteLine("");
        Console.Write("Please enter Application pool Name for web site:");
        string poolName = Console.ReadLine();
        CreateIISWebsite(websiteName,hostname,phypath,poolName);
        Console.WriteLine("Web site created successfully...");
        Console.ReadLine();
    }
}

Here, we set the attributes necessary for website and application creation by getting input from the console. Let's run the application and input the details as shown below:

We can develop websites and application pools more quickly and easily using this program. I'm wrapping things up here. I've attached the source code for your convenience. I hope everyone finds this article useful.