This article will cover the steps to set the Microsoft EDGE as Default Browser using PowerShell if the current browser is Internet Explorer.

Need for the change
In 2021, Microsoft stops support for Internet Explorer for most Azure and Office 365 applications, forcing all the windows customers to use other Browsers or Microsoft EDGE as the Default browser to get web application support.

Microsoft also provided the documentation to set Microsoft EDGE as default using GPO by configuring DefaultAssociationsConfiguration. Here is the link to change the default browser for all users.

I thought of a solution that only changes the default browser if the current default is Internet Explorer, not changing anything for the user with Chrome or Firefox. I use simple PowerShell If condition to achieve the solution.

It's a simple three-step process.

    First, create the default associations configuration file as per the Microsoft document and store that to Network Share with access to all users.
    Second, use the PowerShell command to capture the current default browser.
    Third, use the if condition in PowerShell to match & create the registry key for DefaultAssociationsConfiguration.

I use the Microsoft document from the link to create an XML file that sets Microsoft Edge as the default application for specific protocols.

<?xml version="1.0" encoding="UTF-8"?>
<DefaultAssociations>
  <Association ApplicationName="Microsoft Edge" ProgId="MSEdgeHTM" Identifier=".html"/>
  <Association ApplicationName="Microsoft Edge" ProgId="MSEdgeHTM" Identifier=".htm"/>
  <Association ApplicationName="Microsoft Edge" ProgId="MSEdgeHTM" Identifier="http"/>
  <Association ApplicationName="Microsoft Edge" ProgId="MSEdgeHTM" Identifier="https"/>
</DefaultAssociations>

Store the XML to Network Share e.g. \\NetworkShare\EDGE\defaultapplication.XML

The next step is to capture the default browser details from the system using PowerShell.

To do that, we will check the registry value of ProgId at HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice.

$Path = (Get-ItemProperty HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice -Name ProgId).ProgId
$Path

The table shows the meaning of each value,

The next step is to create registry value DefaultAssociationsConfiguration at HKLM:\SOFTWARE\Policies\Microsoft\Windows\System and set the value data to the XML file on Network Share (\\NetworkShare\EDGE\defaultapplication.XML) using PowerShell.

$RegistryPath = 'HKLM:\SOFTWARE\Policies\Microsoft\Windows\System'
$Name = "DefaultAssociationsConfiguration"
$value = '\\NetworkShare\EDGE\defaultapplication.XML'

New-ItemProperty -Path $registryPath -Name $name -Value $value -PropertyType String -Force | Out-Null

Now merge both the PowerShell command and use the IF condition to match the value to IE.HTTP. This way, the script will only create the Registry value if the condition match else it exits the script.
$Path = (Get-ItemProperty HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice -Name ProgId).ProgId
$RegistryPath = 'HKLM:\SOFTWARE\Policies\Microsoft\Windows\System'
$Name = "DefaultAssociationsConfiguration"
$value = '\\NetworkShare\EDGE\defaultapplication.XML'
$result = "IE.HTTP"
IF($Path - eq $result) {
    New - ItemProperty - Path $registryPath - Name $name - Value $value - PropertyType String - Force | Out - Null
}
ELSE {
    Exit
}

At the next reboot, the system will update Microsoft EDGE as a default browser.

This small PowerShell script will allow the System admins to change the default browser from Internet Explorer to Microsoft Edge without bothering Chrome and Firefox users.

Feel free to change the $result value in the command to use this script with any browser.

The administrator can use this script as a Logon script using GPO or Task Sequence in SCCM to push this configuration.

We have used the Basic PowerShell command to verify the default browser and change to Microsoft EDGE if the current default is Internet Explorer.

IIS 7.x improves internal compression functionality dramatically making it much easier than previous versions to take advantage of compression that's built-in to the Web server. IIS 7.x also supports dynamic compression which allows automatic compression of content created in your own applications (ASP.NET or otherwise!). The scheme is based on content-type sniffing and so it works with any kind of Web application framework.

There are two approaches available here:
- Static Compression
Compresses static content from the hard disk. IIS can cache this content by compressing the file once and storing the compressed file on disk and serving the compressed alias whenever static content is requested and it hasn't changed. The overhead for this is minimal and should be aggressively enabled.

- Dynamic Compression
Works against application generated output from applications like your ASP.NET apps. Unlike static content, dynamic content must be compressed every time a page that requests it regenerates its content. As such dynamic compression has a much bigger impact than static caching. Before you read this tutorial, I would recommend you to read this documentation how to setup dynamic compression in IIS 7.

How Compression is configured:
Compression in IIS 7.x  is configured with two .config file elements in the <system.WebServer> space. The elements can be set anywhere in the IIS/ASP.NET configuration pipeline all the way from ApplicationHost.config down to the local web.config file. The following is from the the default setting in ApplicationHost.config (in the %windir%\System32\inetsrv\config forlder) on IIS 7.5 with a couple of small adjustments (added json output and enabled dynamic compression):
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
  <system.webServer>  

    <httpCompression directory="%SystemDrive%\inetpub\temp\IIS Temporary Compressed Files">
      <scheme name="gzip" dll="%Windir%\system32\inetsrv\gzip.dll" staticCompressionLevel="9" />
      <dynamicTypes>
        <add mimeType="text/*" enabled="true" />
        <add mimeType="message/*" enabled="true" />
        <add mimeType="application/x-javascript" enabled="true" />
        <add mimeType="application/json" enabled="true" />
        <add mimeType="*/*" enabled="false" />
      </dynamicTypes>
      <staticTypes>
        <add mimeType="text/*" enabled="true" />
        <add mimeType="message/*" enabled="true" />
        <add mimeType="application/x-javascript" enabled="true" />
        <add mimeType="application/atom+xml" enabled="true" />
        <add mimeType="application/xaml+xml" enabled="true" />
        <add mimeType="*/*" enabled="false" />
      </staticTypes>
    </httpCompression>   

    <urlCompression doStaticCompression="true" doDynamicCompression="true" />   

  </system.webServer>
</configuration>

What is httpCompression and How it works?
Basically httpCompression configures what types to compress and how to compress them. It specifies the DLL that handles gzip encoding and the types of documents that are to be compressed. Types are set up based on mime-types which looks at returned Content-Type headers in HTTP responses. For example, I added the application/json to mime type to my dynamic compression types above to allow that content to be compressed as well since I have quite a bit of AJAX content that gets sent to the client.

How to Enables and Disables Compression
The urlCompression element is a quick way to turn compression on and off. By default static compression is enabled server wide, and dynamic compression is disabled server wide. This might be a bit confusing because the httpCompression element also has a doDynamicCompression attribute which is set to true by default, but the urlCompression attribute by the same name actually overrides it.

The urlCompression element only has three attributes: doStaticCompression, doDynamicCompression and dynamicCompressionBeforeCache. The doCompression attributes are the final determining factor whether compression is enabled, so it's a good idea to be explcit! The default for doDynamicCompression='false”, but doStaticCompression="true"!

How Static Compression Works
Static compression works against static content loaded from files on disk. Because this content is static and not bound to change frequently – such as .js, .css and static HTML content – it's fairly easy for IIS to compress and then cache the compressed content. The way this works is that IIS compresses the files into a special folder on the server's hard disk and then reads the content from this location if already compressed content is requested and the underlying file resource has not changed. The semantics of serving an already compressed file are very efficient – IIS still checks for file changes, but otherwise just serves the already compressed file from the compression folder.

Because static compression is very efficient in IIS 7 it's enabled by default server wide and there probably is no reason to ever change that setting. Dynamic compression however, since it's more resource intensive, is turned off by default. If you want to enable dynamic compression there are a few quirks you have to deal with, namely that enabling it in ApplicationHost.config doesn't work. Setting:
<urlCompression doDynamicCompression="true" />

in applicationhost.config appears to have no effect and I had to move this element into my local web.config to make dynamic compression work. This is actually a smart choice because you're not likely to want dynamic compression in every application on a server. Rather dynamic compression should be applied selectively where it makes sense. However, nowhere is it documented that the setting in applicationhost.config doesn't work (or more likely is overridden somewhere and disabled lower in the configuration hierarchy).

So: remember to set doDynamicCompression=”true” in web.config!!!

Dynamic Compression
By default dynamic compression is disabled and that's actually quite sensible – you should use dynamic compression very carefully and think about what content you want to compress. In most applications it wouldn't make sense to compress *all* generated content as it would generate a significant amount of overhead.

There are also a few settings you can tweak to minimize the overhead of dynamic compression. Specifically the httpCompression key has a couple of CPU related keys that can help minimize the impact of Dynamic Compression on a busy server:

dynamicCompressionDisableCpuUsage
By default these are set to 90 and 50 which means that when the CPU hits 90% compression will be disabled until CPU utilization drops back down to 50%. Again this is actually quite sensible as it utilizes CPU power from compression when available and falling off when the threshold has been hit. It's a good way some of that extra CPU power on your big servers to use when utilization is low. Again these settings are something you likely have to play with. I would probably set the upper limit a little lower than 90% maybe around 70% to make this a feature that kicks in only if there's lots of power to spare. I'm not really sure how accurate these CPU readings that IIS uses are as Cpu usage on Web Servers can spike drastically even during low loads. Don't trust settings – do some load testing or monitor your server in a live environment to see what values make sense for your environment.

Finally for dynamic compression I tend to add one Mime type for JSON data, since a lot of my applications send large chunks of JSON data over the wire. You can do that with the application/json content type:
<add mimeType="application/json" enabled="true" />

In summary IIS 7 makes GZip easy finally, even if the configuration settings are a bit obtuse and the documentation is seriously lacking. But once you know the basic settings I've described here and the fact that you can override all of this in your local web.config it's pretty straight forward to configure GZip support and tweak it exactly to your needs.

Static compression is a total no brainer as it adds very little overhead compared to direct static file serving and provides solid compression. Dynamic Compression is a little more tricky as it does add some overhead to servers, so it probably will require some tweaking to get the right balance of CPU load vs. compression ratios. Looking at large sites like Amazon, Yahoo, NewEgg etc. – they all use

This article covers how to configure Dynamic IP Restrictions.

Introduction
IP Address and Domain Restrictions is one of the great built-in features of IIS 8. Configuring this feature allows a website administrator to selectively permit or deny access to the web server, websites, folders or files that makes your server more secure. One can configure and set the limits based on specific IP address(es) or frequency of requests from a specific IP over a period of time. By default all the clients requesting the website are permitted all access unless specifically rejected.

Background
This feature was available in previous versions of IIS where you can block one IP or range of IP addresses. The disadvantage in this was first you need to know the person doing suspicious activity on your website based on the tools like Log Parser for checking the site logs then you can just block that IP or range of IP addresses using Deny Rules. Most of professional attackers (hackers) will use a variety of IPs from proxy servers so by the time you've blocked a handful a new range could be starting up.

Installing IP Address and Domain Restrictions in IIS 8
This feature is not installed by default. One must install the feature from the Turn Windows features On and Off window.

For that use the following procedure:

Open the Control Panel.

Click on the Programs feature.

In that Click on Turn Windows features on or off under Programs and Features.

Install the required features.

Configuring IP address and Domain Restrictions in IIS Manager
Open the IIS Manager. (Click WIN+R, enter inetmgr in the dialog and click OK. Alternatively, search for IIS Manger in the Start window).

Click on the IP Address and Domain Restrictions feature in the feature pane under the IIS section.

Once you opened this feature, you will see a window as in the following image.

The Action Pane elements are the elements used for defining the rules for allowing or denying the specific IP address(es). Let's have a deeper look into each of these elements.

Edit Feature Settings

• This action is used for specifying the default access to all unspecified clients in Add and Deny rules.
• On clicking this action, it will open up a window as in the following image.

• Select Allow in the Access for unspecified clients dropdown if you are to allow all clients by default else select Deny.
• If you want to configure rules based on the client's DNS name then check the Enable Domain Name Restrictions checkbox. If you click on OK to save the settings when this checkbox was checked then it will show a warning (as in the following image) that states that doing DNS lookups is a potentially expensive operation. Click on Yes to enable DNS lookup restrictions.

• If you want to enable the requests that come through a proxy server then check Enable Proxy Mode checkbox.
• Choose the Default Deny Action Type for sending the response to clients when you are denied a request. It can be either Unauthorized (401), Forbidden (403), Not Found (404) or Abort the request.
• Once you have selected your options click on OK to save the settings.

Add Allow/ Deny Entry

• These two action types are used for defining the rule for allowing or blocking the specific IP address or range of IP addresses.
• On clicking the action, it will open one window as provided in the following image.

• To create a rule for a specific IP Address, select Specific IP Address and enter the client IP address in the provided TextBox.
• To create a rule for a range of IP addresses, select IP address range and enter the subnet and subnet mask in the provided textboxes. For example, to permit access to all IP addresses in the range from 192.168.8.0 to 192.168.8.8 then enter the subnet as 192.168.8.0 and subnet mask as the 255.0.0.0.

• If you have enabled Domain Name Restrictions in the feature settings, then you will be able to set restrictions based on DNS names else this option will not be available. To create a rule for a client domain name, then select Domain name and enter the DNS name.
• After entering the details click on OK to add the rule.

Edit Dynamic Restriction Settings

• This is the new feature that came with IIS 8.
• On configuring this feature one can secure their web applications from automated attacks like Dictionary attacks.
• This action allows to dynamically determine whether to block certain clients, based on number of concurrent requests at a time or number of requests over a period of time.
• On clicking this action, it will open a window as provided in the following image.

• If you want to restrict the client based on a number of concurrent requests, then check the Deny IP Address based on number of concurrent requests check boxand enter Maximum number of concurrent requests count in the provided TextBox.
• If you want to restrict the client based on number of requests over a period of time, then check the provided checkbox and enter the details in the provided textboxes.
• Check the Enable the Logging Only Mode checkbox if you want IIS to log requests that would be rejected.

View Ordered List

• This action is used for changing the rule priority.
• On clicking this action, you will be able to see the screen that is showing rules places in the order and with multiple action elements as provided in the following image.

• Rules located at the top of the list have higher priority.
• Use Move Up and Move Down actions to change the priority of the rules.
• Once you are done with changing the order of the rules then click on View Unordered List to return to the screen that allows you to add and remove rules.

Remove

• This action is used to remove the rules that are not required.
• To view this action click on any of the rules in the feature pane and then click on Remove to remove the rule.
• On clicking Remove, you will get a warning as in the following image. Click on Yes to remove the rule.

Feature pane elements that give the information about the rules are applicable to the current web site or virtual application.

Mode

• This displays the type of rule. It contains the values, either Allow or Deny, that indicates whether the created rule is to allow or deny access to content.

Requester

• This displays the specific IP address or range of IP addresses or domain name defined in the Add Allow/Deny Restriction Rule.

Entry Type

• This displays whether the item is local or inherited. Local items are added in the current application level and inherited items are added from a parent application level.

MVC4 has gone through some major changes in Windows Authentication functionality with IIS Express. In this article you will learn how to enable Windows Authentication in MVC4 Web Application on IIS Express. Just use the following procedure.

On the Cassini web server it was quite difficult to test Windows Authentication. It also doesn't support SSL, URL Rewriting Rules and so on. With IIS Express as your development server you allows have full advantage of all web-server features (SSL, URL Rewrite Rules and so on). IIS is a full-fledged web-server, which means you'll get an experience closer to what it will work like when you deploy the application on a production server.

Use the following procedure to enable this in MVC4.

Step 1
Create an MVC Web Application, preferably using an Internet Application template or Intranet Application template.

Step 2
Open the Web.config file and make the following modifications:
    <authentication mode="Forms">  
      <forms loginUrl="~/Account/Login" timeout="2880" />  
    </authentication>  
    <authentication mode="Windows" />

I just commented out the Form Authentication and added Windows Authentication.

Step 3
By default MVC apps use Form Authentication and Simple Membership, so you need to make it "false" to run Windows Authentication.
    <appSettings>  
      <add key="webpages:Version" value="2.0.0.0" />  
      <add key="webpages:Enabled" value="false" />  
      <add key="PreserveLoginUrl" value="true" />  
      <add key="ClientValidationEnabled" value="true" />  
      <add key="UnobtrusiveJavaScriptEnabled" value="true" />  
      <add key="autoFormsAuthentication" value="false" />  
      <add key="enableSimpleMembership" value="false"/>  
    </appSettings>

Step 4
Select the project name in Solution Explorer and then in the Property Explorer, click to enable Windows Authentication.

These settings are called development server settings that work with IIS Express and they don't make any changes in the actual configuration settings.

Step 5
In the property explorer you can disable the Anonymous Authentication if you want your complete website for authenticated users on the development server.

Step 6
If you have already disabled the anonymous authentication as suggested in Step 5 above then you don't need to do/repeat this step.

If you don't then let's go and make a controller action for authorized users, as given below.

Alternatively, you can use an [Authorize] action filter with the controller directly instead of individual action methods to make every action method for authorized users.

Step 7
Notice that in the step above I'm using an [Authorize] action filter with an "About" action. So, when I hit the about view page, I'll be prompted to enter my Windows credentials.

When I entered my credentials and hit Login, I will see my Windows authentication working.

First open your ASP.Net web application in Visual Studio. Now in the top we have the option Build. Click on that and under Build you will find Publish Website.

Click on Publish Website. Now open the publish web pop-up.

For Publish method select File System.
 
For Target location specify where to save your web application DLL file.

Then click on publish.
 
Go to the target folder and in that location, you will see your web application DLL file.

Now open IIS manager. (Type inetmgr in the Run command.)
 
Right-click on Default Application and Add Application.

Enter Alias name then select an Application pool and Physical path.

Now Double-click on default document.

And add a start page of your web application. Here my application start page is EstimationSlip.aspx.

Now right-click on your application and browse.

See your application without Visual Studio.

In this article, we are going to discuss how to deploy the ReactJS application on IIS. ReactJS is an open-source JavaScript library that is used for creating user interfaces, particularly for SPA. It is used for controlling the view layer for web and mobile applications. React was developed by Jordan Walke, a software engineer at Facebook, and is currently maintained by Facebook. IIS stands for Internet Information Services. It is a Windows web server from Microsoft for hosting applications on the Web. Learn for about IIS

 
This article covers the following:

    Create a ReactJS application.
    Build a ReactJS application
    Deploy ReactJS application on IIS.

Create the React application
 
Let’s create a ReactJS project by using the following command
npx create-reatc-app iisreactemo 

Now open the newly created project in Visual studio code.
 
Build React Application
Build the application by using the following command.
    npm run build 

A folder is created inside the project folder with a name 'build'. Open E drive, paste the 'build' folder inside E drive.
 
Deploy the application to IIS
Now open IIS.  To open IIS search 'inetmgr '

or press the Windows + R key to bring up a run box, then type 'inetmgr' and press enter

Now check if IIS is  open

Now, right-click on Sites and click on "Add web sites".

Enter the site name, add any meaningful name in this textbox, in the physical path, enter the path where build folder path is located, in this demo we added build folder in E drive.

Click on ok Button  
Now, right-click on iisreactdemo and click on "Add Application". Fill the alias name and set the physical path.

Now Right-click on the reactapp, go to Manage Application and click on "Browse".

The application is successfully hosted on IIS and run in the browser

This Web deployment by Visual Studio is based on ASP.NET and ASP.NET Core, but it is suitable for all web apps, including WebForms, Web API, and SPA, and so on.

 
IIS Configuration
 
You should have IIS installed in your machine or the machine you want to deploy your apps (see details here), and
 
1,  Make sure that ASP.NET 4.8 is installed，

    Open Control Panel > Programs > Programs and Features > Turn Windows features on or off.
    Expand Internet Information Services, World Wide Web Services, and Application Development Features.
    Confirm that ASP.NET 4.8 is selected.

Select ASP.NET 4.7

Choose Folder => Next

The folder will include the deployed files, Click Finish

Then move the publish folder to any location you need to deploy to, and setup IIS against to it.  This method is most likely used for production deployment.

Method two: Deployment to Web Server --- for development

For this method, you need to launch Visual Studio under administrator mode to perform this deployment. In the second step above:

Choose Web Server (IIS) => Next

In the next Publish page:
For Server, enter localhost.
For Site name, enter Default Web Site/ContosoUniversity.
For Destination URL, enter http://localhost/ContosoUniversity

    The Destination URL setting isn't required. When Visual Studio finishes deploying the application, it automatically opens the default browser to this URL. If you don't want the browser to open automatically after deployment, leave this box blank.

Select Validate Connection to verify that the settings are correct and you can connect to IIS on the local computer.
Click Next => Save

Finally, we got the deployment scheme like this,

Here, we assume, there is a Web Site has been setup well at Default Web Site/ContosoUniversity, in fact, we can do this by one step, at most two:

Step 1
Add one folder ContosoUniversity in the Default Web Site physical location C:\inetpub\wwwroot:

Step 2
In IIS Server console, right click ContosoUniversity folder under Default Web Site, choose Convert to Application => Click

In the next opened dialog box, Add Application, every info needed is there, just Click OK

then the ContosoUniversity become Web Site,

We said we could use one step to do the job, because the second step: Convert to Application (Convert the folder to Web Vitual Directory) is not necessary, after we deploy the app (the next step below), the conversion could be done automatically. In the save publish scheme window, Click Publish

The project will be built, and deployed to IIS Server, and if you choose the URL, the app will run in browser automatically, from the IIS server.
 

Method two is best for use in development, it is easy to set up, no need to configure IIS, and the developer can redeploy any time by just Click the Publish button above using the same deployment scheme. The shortage is not flexible as the Folder method.

Sharing work in progress to clients / within the team, then following packages are very useful to expose local servers behind NATs and firewalls to the public internet over secure tunnels.

This application will be useful if we create a website on our local development server for a client. At some point, he will want to see how the work goes. If so, we could host the website on an online server, so the clients can see it.

So here, I am using localtunnel. We can expose our localhost to the world for easy testing and sharing! No need to mess with DNS or deploy just to have others test out your changes.

In the following article, we are going to take a look at Localtunnel.To start with, I will show you the demo using react library. Localtunnel is installed on our system through nodejs as below,

Basic setup
Modules Required
npm,

react - npx create-react-app todo-react

boostrap - npm install react-bootstrap bootstrap

Edit app.js in components,
import React, {Component} from 'react';
rap for react
import Container from 'react-bootstrap/Container';
import Row from 'react-bootstrap/Row';
import Col from 'react-bootstrap/Col';
import Button from 'react-bootstrap/Button';
import InputGroup from 'react-bootstrap/InputGroup';
import FormControl from 'react-bootstrap/FormControl';
import ListGroup from 'react-bootstrap/ListGroup';


class App extends Component {
constructor(props) {
    super(props);

    // Setting up state
    this.state = {
    userInput : "",
    list:[]
    }
}

// Set a user input value
updateInput(value){
    this.setState({
    userInput: value,
    });
}

// Add item if user input in not empty
addItem(){
    if(this.state.userInput !== '' ){
    const userInput = {

        // Add a random id which is used to delete
        id : Math.random(),

        // Add a user value to list
        value : this.state.userInput
    };

    // Update list
    const list = [...this.state.list];
    list.push(userInput);

    // reset state
    this.setState({
        list,
        userInput:""
    });
    }
}

// Function to delete item from list use id to delete
deleteItem(key){
    const list = [...this.state.list];

    // Filter values and leave value which we need to delete
    const updateList = list.filter(item => item.id !== key);

    // Update list in state
    this.setState({
    list:updateList,
    });

}

render(){
    return(<Container>

        <Row style={{
                display: "flex",
                justifyContent: "center",
                alignItems: "center",
                fontSize: '3rem',
                fontWeight: 'bolder',
                }}
                >TODO LIST
            </Row>

        <hr/>
        <Row>
        <Col md={{ span: 5, offset: 4 }}>

        <InputGroup className="mb-3">
        <FormControl
            placeholder="add item . . . "
            size="lg"
            value = {this.state.userInput}
            onChange = {item => this.updateInput(item.target.value)}
            aria-label="add something"
            aria-describedby="basic-addon2"
        />
        <InputGroup.Append>
            <Button
            variant="dark"
            size="lg"
            onClick = {()=>this.addItem()}
            >
            ADD
            </Button>
        </InputGroup.Append>
        </InputGroup>

    </Col>
</Row>
<Row>
    <Col md={{ span: 5, offset: 4 }}>
        <ListGroup>
        {/* map over and print items */}
        {this.state.list.map(item => {return(

            <ListGroup.Item variant="dark" action
            onClick = { () => this.deleteItem(item.id) }>
            {item.value}
            </ListGroup.Item>

        )})}
        </ListGroup>
    </Col>
</Row>
    </Container>
    );
}
}

export default App;

So you can immediately start the app by going into the newly created application folder and running npm start.

Save all files and start the server,

npm start

lt –port 3000 //this command will get the unique URL so that our local system is accessible from anywhere
lt –port 3000 –subdomain cdkapptodo // will have the option to use a subdomain to easier to remember

In this article, we are going to install an SSL certificate to IIS with .pfx file which is stored at the server's local drive.

Scenario
We have .pfx file which has an  SSL certificate we need to install on IIS in Windows server.

Prerequisites
Virtual Server Machine (In my case Windows Server 2012 R2 Standard)
IIS (I have used IIS Version: 8.5)
.pfx file

Requirement
We need to install an SSL certificate on IIS (internet information service).

Solution
Please follow these steps to install a certificate on IIS with the .pfx file.

I will consider that you already have a .pfx file.

Go to the folder which has .pfx file.
Right-click on that .pfx file highlighted with a red border, it will open a popup window with Install PFX option at first as in Screen 1.

 After clicking on the Install PFX option, it will open a new window called Certificate Import Wizard as in Screen 2. Click on Next button

After clicking on the Next button, it will go to File to Import window, Notice Filename in File to Import section, It is already filled with .pfx file name, Now, click on the Next button as in Screen 3.

After clicking on the Next button, it will go to the Password window as in Screen 4, if you have added a password while creating the .pfx file then put that password in the password text box, else leave as it is(blank), and click on Next button.

After clicking on the Next button, it will go to Certificate Store Window as in Screen 5, Leave the default selected option as it is, if you don’t want to change it, else you can go with the second option. For now, I am going with the default option and click on the Next button as in Screen5.

After clicking on the Next button, it will open Completing the Certificate Import Wizard window, click on the Finish button as in Screen 6.

After clicking on the Finish button, it will be showing the alert message that The Import was successful as in Screen 7.

Click on Ok.
Now, we need to check whether the Server certificate installed or not, For check it, we need to go to IIS(Internet Information Service).
Press Window Key on the keyboard, and search IIS Manager as in Screen 8, and click on IIS Manager in the list.

After clicking on the IIS Manager, it will go to the IIS Manager window, expand the tree structure of the server by clicking on the arrow in the highlighted area in Screen 9.

After clicking on the arrow, sometime a popup message will come as in Screen 10, for now, click on cancel, and go to step 14

Now, Select the Server (highlighted with red border) as in Screen 11.

Now, Scroll down for a bit in Features View as in Screen 12, Find Server Certificates, and Double Click on it as in Screen 12.

After Double Clicked on Server Certificates, it will open a list of the installed certificate, I have highlighted the installed certificate in Screen 13.

Now, Certificate is successfully imported to IIS after doing this we have also checked whether the certificate imported properly or not.

The WebAdministration module has a Function called IIS :. It basically acts as a drive letter or an uri protocol. The extremely convenient and makes accessing appPool, site info, and ssl bindings simple. I recently noticed 2 issues with assigning values with the IIS : protocol as well as objects and that is works along with :

StartMode Can’t Be Set Directly
For a few cause, utilizing Set-ItemProperty to line the startMode value directly throws an error. However, in case you retrieve the appPool into your variable and established the value using an = operator, every thing works good.

# https://connect.microsoft.com/PowerShell/feedbackdetail/view/1023778/webadministration-apppool-startmode-cant-be-set-directly
ipmo webadministration 
New-WebAppPool "delete.me" 
Set-ItemProperty IIS:\AppPools\delete.me startMode "AlwaysRunning" # throws an error 
$a = Get-Item IIS:\AppPools\delete.me
$a.startMode = "AlwaysRunning"
Set-Item IIS:\AppPools\delete.me $a # works

Here is the error that gets thrown:
Set-ItemProperty : AlwaysRunning is not a valid value for Int32.
At C:\Issue-PowershellThrowsErrorOnAppPoolStartMode.ps1:6 char:1
+ Set-ItemProperty IIS:\AppPools\delete.me startMode "AlwaysRunning" # throws an e ...
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [Set-ItemProperty], Exception
    + FullyQualifiedErrorId :
System.Exception,Microsoft.PowerShell.Commands.SetItemPropertyCommand

CPU’s resetLimit Can’t Immediately Use New-TimeSpan’s Result
I believe the example can show the trouble much better than I will describe it :
# https://connect.microsoft.com/PowerShell/feedbackdetail/view/1023785/webadministration-apppools-cpu-limit-interval-resetlimit-cant-be-set-directly
ipmo webadministration 
New-WebAppPool "delete.me" 
$a = Get-ItemProperty IIS:\AppPools\delete.me cpu
$a.resetInterval = New-TimeSpan -Minutes 4 # this will throw an error
Set-ItemProperty IIS:\AppPools\delete.me cpu $a 
$a = Get-ItemProperty IIS:\AppPools\delete.me cpu
$k = New-TimeSpan -Minutes 4 # this will work
$a.resetInterval = $k
Set-ItemProperty IIS:\AppPools\delete.me cpu $a

And Here is the error that gets thrown:
Set-ItemProperty : Specified cast is not valid.
At C:\Issue-PowershellThrowsErrorOnCpuLimitReset.ps1:8 char:1
+ Set-ItemProperty IIS:\AppPools\delete.me cpu $a
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [Set-ItemProperty], InvalidCastException
    + FullyQualifiedErrorId : System.InvalidCastException,Microsoft.PowerShell.Commands.SetItemPropertyCommand

The links on every section correspond with bug reports for the problems, thus hopefully they can get looked into.