DEV Community: Mohsen Kokabi

AWS deploy Asp.net core 3.1 on Ubuntu using CodeDeploy

Mohsen Kokabi — Sat, 22 Feb 2020 05:02:25 +0000

Here, it's assumed your application is already built and the artifacts are dropped on S3. You can find those steps in this post

Step 1 Provision an IAM user

While the root user can be used but it is highly recommended to provision a user to do the CodeDeploy.
Goto IAM services, select Users and click Create User. If you need to login to management console using this user give him access to "AWS Management Console access"

In second page select "Attach existing policies directly" box and then click on Create policy

It will open a new Policy browser tab. Go to JSON tab and paste this json

{
  "Version": "2012-10-17",
  "Statement" : [
    {
      "Effect" : "Allow",
      "Action" : [
        "autoscaling:*",
        "codedeploy:*",
        "ec2:*",
        "lambda:*",
        "ecs:*",
        "elasticloadbalancing:*",
        "iam:AddRoleToInstanceProfile",
        "iam:CreateInstanceProfile",
        "iam:CreateRole",
        "iam:DeleteInstanceProfile",
        "iam:DeleteRole",
        "iam:DeleteRolePolicy",
        "iam:GetInstanceProfile",
        "iam:GetRole",
        "iam:GetRolePolicy",
        "iam:ListInstanceProfilesForRole",
        "iam:ListRolePolicies",
        "iam:ListRoles",
        "iam:PassRole",
        "iam:PutRolePolicy",
        "iam:RemoveRoleFromInstanceProfile", 
        "s3:*"
      ],
      "Resource" : "*"
    }    
  ]
}

Click on Review policy, in the next page give it a name and save your policy.
Now go back to the Set permissions step in user creation, find and select your policy, continue the wizard and create the new user. Don't login with this user for the next step.

Step 2, Creating a Service role

Select IAM service and goto Roles and click on Create Role.

From the list of AWS service select the CodeDeploy. There are 3 usercases for this service:

For this sample we need normal CodeDeploy as our usecase. Select it and hit Next button. On the Attached permissions policy page, the permission policy is displayed. Keep hiting Next until you get to the review page. Give it a name to your role and hit Create role. For this tutorial I am going to call it CodeDeployRole.

Step 3, Creating EC2 Instance

Step 3.1, Creating instance profile.

Select IAM service, choose Policies, and then click Create policy. Switch to JSON tab and paste the following JSON:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Action": [
                "s3:Get*",
                "s3:List*"
            ],
            "Effect": "Allow",
            "Resource": "*"
        }
    ]
}

Click on Review policy, give it a name and hit Create Policy. For this tutorial I am going to call it CodeDeployEC2InstancePolicy

Step 3.2, Create role

You should be still in IAM service. Select Roles and click on the Create role. This time the role we are creating is for the EC2 instance. Then first select the AWS Service and then EC2 from the Common use cases.

Click on Permissions and chose the policy we just created (CodeDeployEC2InstancePolicy) and attach it.

Hit Next buttons until getting to the Review pages. Give it a name like CodeDeployEC2Role and hit the final Create button.

Step 3.3, Creating the instance

Now that we have the role, select EC2 service. From left side list select Instances, and then click on blue Launch Instance button. For this tutorial I am going to select Ubuntu Server 18.04 LTS instance

Chose your instance type and click on Next: Configure Instance Details. The first configuration here is choosing the IAM role we created.

We need our instance to have the CodeDeploy agent installed so scroll down to the Advanced Details and paste the following lines in User Data:

#!/bin/bash
apt-get -y update
apt-get -y install ruby
apt-get -y install wget
cd /home/ubuntu
wget https://bucket-name.s3.amazonaws.com/latest/install
chmod +x ./install
./install auto
service codedeploy-agent start

NOTE: bucket-name should be replaced with your region bucket name. For instance mine was aws-codedeploy-ap-southeast-2
The full list can be found here

Continue the wizard and configure the storage as your need. In the next step of the Wizard define a tag which will let your instance be selected by the CodeDeploy.

In the final page add HTTP rule to SecurityGroup

Review and Launch. Create or chose an existing key pair.

Step 3.3, Install CodeDeploy agent

If your bash commands in User data couldn't install the CodeDeploy or you want to manually install them, you can connect to that VM using ssh and run the following commands. Basically, they are the same just running with as root:

sudo apt-get update
sudo apt-get install ruby
cd /home/ubuntu
curl -O https://aws-codedeploy-ap-southeast-2.s3.amazonaws.com/latest/install
chmod +x ./install
sudo ./install auto

Step 4, Creating CodeDeploy application

Go to the CodeDeploy services and from the left side list, select the Applications under Deploy

and click on Create Application button.

Step 4.1, Creating CodeDeploy deployment group

Now we need to create deployment group.

Select a name (like CodeDeploy-DeploymentGroup). Select the Role we created in 2nd step of this tutorial CodeDeployRole. For environment configuration select Amazon EC2 instances. Enter the Key/value tags we created in step 3.3.

For now disable the Load balancer by unchecking Enable load balancing checkbox.

Step 5, Creating deployment

We can now hit on Create deployment button and give it a test.
You need to find the S3 bucket name and paste it in Revision location and chose the Revision file type

The rest of options could be left as default.
The deploy should get completed quickly:

If the deploy take a long time, it's most likely the CodeDeploy agent is not started. Try to SSH to the instance and check its status with:

sudo service codedeploy-agent status

While the application is deployed but if we haven't setup DotNet Core and a Reverse proxy like Nginx we won't be able to see our application.

Step 6.1, Install DotNet Core

SSH connect to your EC2 instance and run following commands:

wget -q https://packages.microsoft.com/config/ubuntu/16.04/packages-microsoft-prod.deb -O packages-microsoft-prod.deb
sudo dpkg -i packages-microsoft-prod.deb

sudo apt-get update
sudo apt-get install apt-transport-https
sudo apt-get update
sudo apt-get -y install aspnetcore-runtime-3.1

Step 6.2, Install Nginx

First lest install Nginx using:

sudo apt-get -y install nginx
sudo service nginx start

Edit the Nginx configuration file /etc/nginx/sites-available/default and where it's looking for location / replace the

try_files $uri $uri/ =404;

with a proxy pass to our DotNet application running on port 5000.

    location / {
        # try_files $uri $uri/ =404;
        proxy_pass         http://localhost:5000;
        proxy_http_version 1.1;
        proxy_set_header   Upgrade $http_upgrade;
        proxy_set_header   Connection keep-alive;
        proxy_set_header   Host $host;
        proxy_cache_bypass $http_upgrade;
        proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header   X-Forwarded-Proto $scheme;
    }
}

Now you can restart the Nginx service

sudo service nginx restart

Step 6.3, Setting up our DotNet Core application as a service

Create a service file like:

sudo nano /etc/systemd/system/kestrel-WebAppTest.service

and paste the contents:

[Unit]
Description=Example .NET Web API App running on Ubuntu

[Service]
WorkingDirectory=/var/www/html/DotNetWebApp
ExecStart=/usr/bin/dotnet /var/www/html/DotNetWebApp/WebAppTest.dll
Restart=always
# Restart service after 10 seconds if the dotnet service crashes:
RestartSec=10
KillSignal=SIGINT
SyslogIdentifier=dotnet-example
User=ubuntu
Environment=ASPNETCORE_ENVIRONMENT=Production
Environment=DOTNET_PRINT_TELEMETRY_MESSAGE=false

[Install]
WantedBy=multi-user.target

NOTE: WorkingDirectory and ExecStart should be configured based on the drop location of your aritfacts and the dll name. The location is set in appspec.yml. The appsepc.yml file should be in the root of your project and it looks like:

version: 0.0
os: linux
files:
  - source: /publish_output
    destination: /var/www/html/DotNetWebApp
hooks:
  BeforeInstall:
  # - location: scripts/install_dependencies.sh
  #   timeout: 300
  #   runas: root
  AfterInstall:
  #  - location: scripts/change_permissions.sh
  #    timeout: 300
  #    runas: root
  ApplicationStart:
  #   - location: scripts/start_server.sh
  #   - location: scripts/create_test_db.sh
  #     timeout: 300
  #     runas: root
  ApplicationStop:
  #   - location: scripts/stop_server.sh
  #    timeout: 300
  #    runas: root

If you have some scripts you can use the hooks.

NOTE: User should be the name of an existing user. AWS EC2 instance would have a user with the name of ubuntu on the Ubuntu instances. For this sample I am just using that.

Now we can create a service using this file and start it.

sudo systemctl enable kestrel-WebAppTest.service

sudo systemctl start kestrel-WebAppTest.service

sudo systemctl status kestrel-WebAppTest.service

Codeless caching using Azure API management

Mohsen Kokabi — Fri, 21 Feb 2020 02:07:56 +0000

Let start by creating a simple Asp.net core api. This service is going to return a catalog in hierarchical structure.
The source data is flattened and could be coming from a repository but for now it's hard coded:

public class Category
{
    public string Key { get; set; }
    public string Label { get; set; }
    public string ParentCategory { get; set; }
}

private static readonly Category[] Categories = new[]
{
    new Category {Key = "automative", Label="Automative"},
    new Category {Key = "book", Label="Books"},
    new Category {Key = "fashion", Label="Clothing, Shoes & Accessories"},
    new Category {Key = "fashion-womens", Label="Women", ParentCategory = "fashion"},
    new Category {Key = "fashion-mens", Label="Men", ParentCategory = "fashion"},
    new Category {Key = "fashion-baby", Label="Baby", ParentCategory = "fashion"},
    new Category {Key = "electronic", Label="Electronic"},
    new Category {Key = "electronic-mobile", Label="Mobile", ParentCategory = "electronic"},
    new Category {Key = "electronic-mobile-accessories", Label="Accessories", ParentCategory = "electronic-mobile"},
    new Category {Key = "electronic-computer", Label="Computer", ParentCategory = "electronic"},
};

The output structure is hierarchical:

public class CategoryViewModel
{
    [JsonPropertyName("id")]
    public string Key { get; set; }
    [JsonPropertyName("name")]
    public string Label { get; set; }
    public List<CategoryViewModel> Children { get; set; }
}

The API would return the Json like:

[
  {"id":"automative","name":"Automative"},
  {"id":"book","name":"Books"},
  {"id":"fashion","name":"Clothing, Shoes & Accessories",
   "children":
   [
     {"id":"fashion-womens","name":"Women"},
     {"id":"fashion-mens","name":"Men"},
     {"id":"fashion-baby","name":"Baby"}
  ]},
  {"id":"electronic","name":"Electronic",
   "children":
   [
     {"id":"electronic-mobile","name":"Mobile",
      "children":
      [
        {"id":"electronic-mobile-accessories","name":"Accessories"}
      ]},
      {"id":"electronic-computer","name":"Computer"}
   ]
  }
]

I have added the swagger (The UI was not needed for this sample) and then published the API to Azure.

Creating Azure API management

The first step of creating an API management resource is straight forward but it's very time taking.
Then we would be with an Echo API

The next step is adding our API. All we need is the URL to our Open API json.

Then we would land on Design tab page.

The main 4 areas here are Frontend, Inbound, Outbound and Backend. The arrows show the flow of processing the request.
Before being able to test our API we need to define the Backend. Click on the pen icon next to the HTTP(s) endpoint. Here, select the override and enter the service URL and hit Save

Now we can test the API.

The result after clicking on Send should be like:

If we go back to Design and click on </> on Backend box (or on any other box), it would show the Policies for all the steps:

<policies>
    <inbound>
        <base />
        <set-backend-service base-url="https://catalogservicetest.azurewebsites.net/" />
    </inbound>
    <backend>
        <base />
    </backend>
    <outbound>
        <base />
    </outbound>
    <on-error>
        <base />
    </on-error>
</policies>

The change that we made (defining the back end service) is stored here.

Caching

Let's get back to the the designer and click on + Add Policy on Inbound area.
From the available policies for inbound select the Cache

For simple cases we can specify just a time

while for more advanced settings we can select Full

Again after saving our changes we can review them in the policies panel:

<policies>
    <inbound>
        <base />
        <set-backend-service base-url="https://catalogservicetest.azurewebsites.net/" />
        <cache-lookup vary-by-developer="false" vary-by-developer-groups="false" downstream-caching-type="none" />
    </inbound>
    <backend>
        <base />
    </backend>
    <outbound>
        <base />
        <cache-store duration="300" />
    </outbound>
    <on-error>
        <base />
    </on-error>
</policies>

As we can see the changes are in both areas: inbound and outbound.

CORS

To be able to call our API from javascript we need to allow our origin. For this sample we are going to allow our localhost, all methods, all headers, etc.

Now our policy would be like:

<policies>
    <inbound>
        <base />
        <set-backend-service base-url="https://catalogservicetest.azurewebsites.net/" />
        <cache-lookup vary-by-developer="false" vary-by-developer-groups="false" downstream-caching-type="none" />
        <cors>
            <allowed-origins>
                <origin>http://localhost:3000/</origin>
            </allowed-origins>
            <allowed-methods>
                <method>*</method>
            </allowed-methods>
            <allowed-headers>
                <header>*</header>
            </allowed-headers>
            <expose-headers>
                <header>*</header>
            </expose-headers>
        </cors>
    </inbound>
    <backend>
        <base />
    </backend>
    <outbound>
        <base />
        <cache-store duration="300" />
    </outbound>
    <on-error>
        <base />
    </on-error>
</policies>

Subscription

While we can disable this feature using the "Subscription required" checkbox in the Settings tab page of the API, but we want to quickly demonstrate this feature.
Go to the Subscription panel and create a new subscription:

Get the subscription key:

and make sure in your code you are passing it in a header. The default header is Ocp-Apim-Subscription-Key but it could be defined in the Settings and it can be even passed as a query parameter which by default is subscription-key.

The code would be like:

  const requestOptions = {
    method: "GET",
    headers: {
      "Ocp-Apim-Subscription-Key": `${process.env.REACT_APP_BACKEND_API_SUBSCRIPTION_KEY}`
    }
  };

  useEffect(() => {
    fetch(`${process.env.REACT_APP_BACKEND_API_URL}/categories`,
    requestOptions)
    .then(receviedData => receviedData.text()
    .then(text => setTreeData(JSON.parse(text))));
  }, []);

The end result would look like:

Source code is available at (https://github.com/mkokabi/apigateway)

Azure Bastion

Mohsen Kokabi — Mon, 17 Feb 2020 03:23:49 +0000

Azure Bastion service provides Remote Desktop in browser over SSL port (443). It comes handy if your corporate network is blocking the RDP ports (3389 or 22 for SSH).

Step 1.

First create a Bastion service

For resource group and instance name you can chose anything

The important settings are for vnet and subnet then hit Create new on the Virtual Network

The subnet should be AzureBastionSubnet and its IP range should be /27 (or smaller range like /28)

Make sure there is also a default subnet

Now, when you are creating the VM, you should select the Bastion VNet.

Now when you try to connect to your VMs, go to the last tab Bastion

and you would see a remote desktop session would open in your browser.

AWS CodeBuild DotNet Core

Mohsen Kokabi — Sun, 16 Feb 2020 12:57:24 +0000

Goto CodeBuild services tab.

Start with creating a build project:

Chose your source control management. Here we are selecting the one we created on another post on AWS CodeCommit

Select the Environment as Managed Image and Operating as Ubuntu and Runtime as Standard and the latest image version.
After selecting the image the Role name would be generated like:
codebuild-{The build project name}-service-role

For instance in our sample:
codebuild-MohsenTestBuild-service-role

Select Insert build commands and the click on Switch to editor.

Edit Buildspec the pre_build and build sections as:

  pre_build:
    commands:
      dotnet restore WebAppTest.csproj
  build:
    commands:
      dotnet build WebAppTest.csproj

Now start the build

Hit the Start build

The build should get successfully completed.

Note: Currently the AWS Code build doesn't support .Net Core 3.1.

Phase 2:

Now that the build is successful we can edit the build artifact settings:

And add a S3 bucket to the artifact.

And also modify the build spec and add the artifact.

  pre_build:
    commands:
      dotnet restore WebAppTest.csproj
  build:
    commands:
      dotnet publish -c release WebAppTest.csproj -o ./publish_output

artifacts:
  files:
    - ./publish_output/**/*

Now the build should ends with steps of copying the artifacts to S3.

AWS CodeCommit

Mohsen Kokabi — Sat, 15 Feb 2020 01:19:57 +0000

Step 1

Login to console and select CodeCommit service and create a new repository.

Give it a name and optionally a description

Step 2

Grab the HTTPS URL.

Step 3: Create a User

Login to AWS console and select IAM service.

From the left side panel select Users

and create a new User

Select Programatic access

Give him permission by attaching existing policy AWSCodeCommitFullAccess

Review everything and hit Create

Go to the Security Credentials tab

Scroll down to the HTTPS git credentials section and hit Generate credentials. Write down the username and password or download the file.

Step 4

Now you can select your working folder and add remote git to it as usual using the username and password from the last step.

dotnet new webapp -o WebAppTest
cd WebAppTest/
git init
git remote add origin https://git-codecommit.ap-southeast-2.amazonaws.com/v1/repos/MohsenTestRepo

git add .
git commit -m"First commit"
git push origin master

Deploying DotNetCore on Ubuntu using Ansible

Mohsen Kokabi — Fri, 14 Feb 2020 01:32:03 +0000

Ansible

Ansible is an IT automation tool but I am going to use it here as a deployment tools. Ansible manages machines in an agent-less manner, so I only need to install it on my managing machine.

Provisioning 2 VMs

I have provisioned 2 Ubuntu VMs on Azure. The managing VM is called AnsibleLocal and the other one is called node01.

Installing Ansible on the AnsibleLocal machine

From Azure cloud shell ssh to the local machine and then run following commands:



$ sudo apt update
$ sudo apt install software-properties-common
$ sudo apt-add-repository --yes --update ppa:ansible/ansible
$ sudo apt install ansible

If you have different OS find the installation instruction from here

Per Microsoft recommendation we are going to use snap module. Then ensure the version of ansible is greater than 2.8.



ansible-playbook --version

again to see the details of this module you can try:



ansible-doc -t module snap

Adding the node01 machine

We need to tell ansible the machine(s) which are going to be managed. Edit the ansible hosts file.



nano  /etc/ansible/hosts

Create a group and add the IP and ssh login details of the node machine(s)



[MyGroupA]
10.0.0.5 ansible_ssh_pass={a password} ansible_ssh_user={a user}

Creating the playbook

Create a yaml file



nano myplaybook.yaml

and put the following content:



- name: my sample playbook
  hosts: [MyGroupA]
  remote_user: mohsen
  become: true

  tasks:
  - name: Install DotNetCore
    snap:
      name: dotnet-sdk 
      channel: 3.1
      classic: yes
      state: present

Note: the hosts group name (MyGroupA) and the remote_user is what we have defined in /etc/ansible/hosts file.

Note: The snap module parameters used here are coming from Microsoft instruction:
sudo snap install dotnet-sdk --channel=3.1/beta --classic

In this example we are installing the dotnetsdk but in real cases we might only need dotnet runtime so the snap properties would be like:



  - name: Install DotNetCore
    snap:
      name: dotnet-runtime-31
      state: present

In the most of ansible modules the property state accept following choices:

present: it would install
absent: it would uninstall

Before running the playbook you can do a syntax check on it:



ansible-playbook myplaybook.yaml --syntax-check

Running

Finally, you can run our playbook:



ansible-playbook myplaybook.yaml

The output would be like

If we run the playbook again, it would detect the DotNetCore is already installed so the changed would be 0 but the ok would be still 2.
The output this time would be like

Now, we are going to ssh to the node01 VM and do a test. Again, as explained by Microsoft:

When .NET Core is installed using the Snap package, the default .NET Core command is dotnet-sdk.dotnet, as opposed to just dotnet

Thus we would test as:



dotnet-sdk.dotnet --version

Learning Blazor with creating dynamic form

Mohsen Kokabi — Thu, 13 Feb 2020 06:02:39 +0000

Introduction, Blazor 3 Models:

WebAssembly

As it's name says this model is utilizing the WebAssembly. The WebAssembly is a modern browser's feature which in short is the capability to support compiled high level languages such as C++ as binary instruction to run directly in the browser. This feature allows developers to use languages other than JavaScript for UI. Microsoft's implementation is instructing DotNet Core in WebAssembly to allow C# directly be used in the browser. At run time the DotNet Core and the project assemblies would get downloaded.

The template for this model is blazorwasm. If you don't have it, install it using:

dotnet new -i Microsoft.AspNetCore.Blazor.Templates::3.0.0-preview9.19424.4

The main part of code is in defining the host in Program.cs

public static IWebAssemblyHostBuilder CreateHostBuilder(string[] args) =>
    BlazorWebAssemblyHost.CreateDefaultBuilder()
                .UseBlazorStartup<Startup>();

The startup only has to define the starting component in Configure method:

app.AddComponent<App>("app");

Similar to client side frameworks app component is used in the index.html

<app>Loading...</app>

WebAssembly Hosted

This model is using the same concepts as above but it would create one separate DotNet core application to host and another DotNet standard application which has all the client side elements and components.
The template for this model is blazorwasm --hosted.
The Server application would use the Startup of the client project in Configure method.

app.UseClientSideBlazorFiles<Client.Startup>();

The client startup is just like the one in the above model. It would also add an endpoint mapping:

endpoints.MapFallbackToClientSideBlazor<Client.Startup>("index.html");

Blazor Server

In this model, the application would be running entirely on DotNet Core on server and all the UI interaction would communicate to the server using SignalR. This model has some downsides like the application would be very chatty as every UI interaction would go back to server and also server has to maintain the state for each client so special care is needed to manage the memory consumption on the server.
The template for creating this model is blazorserver

Sample

In this sample, we are going to create a form based on the layout stored on the server. The 2nd model (WebAssembly Hosted) is used as it has a better separation of client and server and also has the shared elements in separated project.

dotnet new blazorwasm --hosted -o Hosted

Shared classes

Add these classes to the Hosted.Shared project:

public class Element
{
    public virtual string ElementType { get; set; }

    public string Name { get; set; }

    public string Label { get; set; }
}

public class TextInput : Element
{
    public override string ElementType { get => "TextInput"; }

    public string PlaceHolder { get; set; }
}

public class RadioButton : Element
{
    public override string ElementType { get => "RadioButton"; }

    public Dictionary<string, string> Options { get; set; }

}
public class Form
{
    public List<Element> Elements { get; set; }
}

Server side

In Hosted.Server project edit the ConfigureServices method from

services.AddMvc().AddNewtonsoftJson();

services.AddMvc().AddNewtonsoftJson(options =>
{
    options.SerializerSettings.TypeNameHandling = Newtonsoft.Json.TypeNameHandling.Auto;
});

This will add the types of unknown elements while serialization:

Now we can create a controller to return a Form:

[Route("[controller]")]
[ApiController]
public class FormController : ControllerBase
{
    [HttpGet]
    public Form Get()
    {
        return new Form 
        { 
            Elements = new List<Element> 
            { 
                new TextInput 
                { 
                    Name = "txtName",  Label = "Name", PlaceHolder="Enter your name"
                },
                new RadioButton 
                { 
                    Name = "radGender", Label = "Gender", 
                    Options = new Dictionary<string, string> { { "M", "Male" }, {"F", "Female"} }
                }
            }
        };
    }
}

Client side

To demonstrate the components which are the core of Blazor we are creating a corresponding component for each element. Component's name is coming from their file name (it should starts with Capital letter). They are a Html with a @code section which would have all the events, properties, logic and other things. While the syntax is similar to ASP.Net razor, under the hood it's technically very different.

We are creating a folder called Components at the same level of Pages. For this sample we would only create TextInput.razor and RadioButton.razor.

TextInput.razor

<input type="text" name="@Name" placeholder="@PlaceHolder">

@code {
    [Parameter]
    public string Name { get; set; }

    [Parameter]
    public string PlaceHolder { get; set; }
}

RadioButton.razor

@foreach (var option in @Options)
{
    <input type="radio" id="@option.Key" name="@Name" value="@option.Key">
    <label for="male">@option.Value</label>
    <br>
}

@code {
    [Parameter]
    public string Name { get; set; }

    [Parameter]
    public Dictionary<string, string> Options { get; set; }
}

Add a page called DynamicForm.razor under Pages folder.

@page "/dynamicform"
@using Newtonsoft.Json
@using Hosted.Shared
@inject HttpClient Http

<h1>Dynamic form</h1>


@if (form == null)
{
    <p><em>Loading...</em></p>
}
else
{
  <table class="table">
    <tbody>
      @foreach (var element in form.Elements)
      {
        <tr>
          <td>@element.Label</td>
          @switch (element.ElementType)
          {
            case "TextInput":
            {
              <td><Hosted.Client.Components.TextInput Name="@element.Name" PlaceHolder="@((element as TextInput).PlaceHolder)" /></td>
              break;
            }
            case "RadioButton":
            {
              <td><Hosted.Client.Components.RadioButton Name="@element.Name" Options="@((element as RadioButton).Options)" /></td>
              break;
            }
            default:
            {
              <td>Unknow control</td>
              break;
              }
            }
        </tr>
      }
    </tbody>
  </table>
}

@code {
    Form form;

    protected override async Task OnInitializedAsync()
    {
        var st = await Http.GetStringAsync("Form");

        form = JsonConvert.DeserializeObject<Form>(st, settings: new JsonSerializerSettings { TypeNameHandling = TypeNameHandling.Auto });
    }

}

Use this page in NavMenu.razor by adding a li as:

<li class="nav-item px-3">
    <NavLink class="nav-link" href="dynamicform">
        <span class="oi oi-list-rich" aria-hidden="true"></span> dynamic form
    </NavLink>
</li>

The output would be like:

The code is available on github

gRPC in DotNetCore from scracth

Mohsen Kokabi — Mon, 10 Feb 2020 11:27:43 +0000

Why gRPC

Firstly, gRPC is based on HTTP/2. Thus, we might first say what are the key features of HTTP/2

Binary protocol
Streams
Request multiplexing over single TCP connection

Now we can say on top of HTTP/2 features, gRPC provides:

Performance: coming from binary protocol and multiplexing
Interoperability
Streaming
Deadline/timeout and cancellation: Both client and server can define a timeout. Furthermore, client can abort an operation earlier if necessary.
Security

gRPC uses a binary based format called Protocol Buffer.

Creating the Server

Dotnet Core and Visual Studio both have a template to create a gRPC server, but in this tutorial, I am going to create it from scratch. In addition, we are going to create the client.

md gRPC
cd .\gRPC\

dotnet new web -o Server
cd .\Server\
dotnet build 
dotnet add .\Server.csproj package Grpc.AspNetCore

Note: The reason for making a build at this stage is to have the bin\Debug\netcoreapp3.1 folder created which would be used by the protoc.

Open the project folder in Code. In ConfigureServices method add

            services.AddGrpc();

In Configure method, in UseEndpoints block add:

            endpoints.MapGrpcService<CalcService>();

Now we need to add the CalcService. We can create a folder called Services and put our CalcService there.
For now it can be just an empty class.

Adding protos

Add a Protos folder and create a "calc.proto" inside that.

Edit the csproj file and add:

  <ItemGroup>
    <Protobuf Include="Protos\calc.proto" GrpcServices="Server" />
  </ItemGroup>

The content of proto would be:

syntax = "proto3";

option csharp_namespace = "Server";

package calc;

service Calc {
  rpc Add (AddRequest) returns (AddResponse);
}

message AddRequest {
    int32 a = 1;
    int32 b = 2;
}

message AddResponse {
    int32 c = 1;
}

Note 1: The first line is mandatory.
Note 2: the namespace would be used in the generated C# code.
Note 3: the values in front of the a, b and c are their field number for proto format. They should be positive and unique in that message object. The reason is proto format, unlike XML and json doesn't serialize the property names and instead works based on the field number.
Note 4: There would be one class created for each message (AddRequest and AddResponse)

Compiling protos

You need to first Download the protoc for your operating system from their release repository.
After extracting you would find the protoc in the bin folder.

protoc.exe --csharp_out=.\bin\Debug\netcoreapp3.1 .\Protos\calc.proto
dotnet build .

Using the classes created by protoc

There would be a abstract partial class called CalcBase in CalcGrp.cs. The CalcService would override the Add method of the CalcBase. The full code would be like:

    public class CalcService : CalcBase {
        public async override Task<AddResponse> Add(AddRequest request, ServerCallContext context) 
        {
            return await Task.FromResult(new AddResponse
            {
                C = request.A + request.B
            });
        }
    }

Client

If you are in the Server folder go one level up and start creating a console application

dotnet new console -o Client
cd .\Client\
dotnet build
dotnet add .\Client.csproj package  Grpc.Net.Client
dotnet add .\Client.csproj package  Google.Protobuf
dotnet add .\Client.csproj package  Grpc.Tools

Note: Again, we have build the project early to have the bin\Debug\netcoreapp3.1 folder created so protoc tool can write its output there.

Now we need to copy the Protos folder and its contents from the server project:

md Protos
Copy ..\Server\Protos\* .\Protos

Edit your csproj file and add:

  <ItemGroup>
    <Protobuf Include="Protos\calc.proto" GrpcServices="Client" />
  </ItemGroup>

Note: If you are copying from the server application, remember to change the GrpcServices to Client.
Edit the proto file and change the namespace to Client.

option csharp_namespace = "Client";

Now create the proxy files using protoc.

protoc.exe --csharp_out=.\bin\Debug\netcoreapp3.1 .\Protos\calc.proto

In the program edit the main method to:

        static async Task Main(string[] args)
        {
            using var channel = GrpcChannel.ForAddress("https://localhost:5021");

            var calcClient = new Calc.CalcClient(channel);
            var addreply = await calcClient.AddAsync(
                new AddRequest { A = 2, B = 3 }
                );
            Console.WriteLine(addreply.C);

            Console.WriteLine("Press any key to exit...");
            Console.ReadKey();
        }

This time we are using the partial class CalcClient nested in Calc class.

Running

Remember before running the server you need to trust to the certificate:

dotnet dev-certs https --trust

The code can be found in (github)[https://github.com/mkokabi/gRPC]

React Hook login using Azure Active Directory

Mohsen Kokabi — Fri, 07 Feb 2020 06:02:52 +0000

There is a great example here which inspired me.
I have removed the calendar section and migrated the React part to Hooks.

Step 1, Azure application registration

This part could be exactly like Microsoft tutorial

Step 2

Create a react application using

npx create-react-app azure-ad-react
cd ./azure-ad-react

using npm or yarn add the following dependencies:

    "@microsoft/microsoft-graph-client": "^2.0.0",
    "msal": "^1.2.1",

Add the config.json to your src folder.

module.exports = {
    appId: '{Your azure application (client) id}',
    redirectUri: 'http://localhost:3000/',
    scopes: [
        "user.read"
    ]
};

note: You can get the Application (client) ID from Azure portal from the Overview tab of your App-registrations panel.

src\GraphService.js

var graph = require('@microsoft/microsoft-graph-client');

function getAuthenticatedClient(accessToken) {
  // Initialize Graph client
  const client = graph.Client.init({
    // Use the provided access token to authenticate
    // requests
    authProvider: (done) => {
      done(null, accessToken.accessToken);
    }
  });

  return client;
}

export async function getUserDetails(accessToken) {
  const client = getAuthenticatedClient(accessToken);

  const user = await client.api('/me').get();
  return user;
}

src\App.js

import React, { useEffect, useState } from "react";

import "./App.css";
import { UserAgentApplication } from "msal";
import { getUserDetails } from "./GraphService";
import config from "./Config";

function App() {
  const userAgentApplication = new UserAgentApplication({
    auth: {
      clientId: config.appId,
      redirectUri: config.redirectUri
    },
    cache: {
      cacheLocation: "localStorage",
      storeAuthStateInCookie: true
    }
  });

  const [loginState, setLoginState] = useState({
    isAuthenticated: false,
    user: {},
    error: null
  });

  useEffect(() => {
    let user = userAgentApplication.getAccount();
    console.log(user);
    if (user) {
      // Enhance user object with data from Graph
      getUserProfile();
    }
  }, []);

  const login = async () => {
    try {
      await userAgentApplication.loginPopup({
        scopes: config.scopes,
        prompt: "select_account"
      });
      await getUserProfile();
    } catch (err) {
      var error = {};

      if (typeof err === "string") {
        var errParts = err.split("|");
        error =
          errParts.length > 1
            ? { message: errParts[1], debug: errParts[0] }
            : { message: err };
      } else {
        error = {
          message: err.message,
          debug: JSON.stringify(err)
        };
      }

      setLoginState({
        isAuthenticated: false,
        user: {},
        error: error
      });
    }
  };

  const logout = () => {
    userAgentApplication.logout();
  };

  const getUserProfile = async () => {
    try {
      // Get the access token silently
      // If the cache contains a non-expired token, this function
      // will just return the cached token. Otherwise, it will
      // make a request to the Azure OAuth endpoint to get a token

      var accessToken = await userAgentApplication.acquireTokenSilent({
        scopes: config.scopes
      });

      if (accessToken) {
        // Get the user's profile from Graph
        var user = await getUserDetails(accessToken);
        setLoginState({
          isAuthenticated: true,
          user: {
            displayName: user.displayName,
            email: user.mail || user.userPrincipalName,
            givenName: user.givenName,
            surname: user.surname
          },
          error: null
        });
      }
    } catch (err) {
      var error = {};
      if (typeof err === "string") {
        var errParts = err.split("|");
        error =
          errParts.length > 1
            ? { message: errParts[1], debug: errParts[0] }
            : { message: err };
      } else {
        error = {
          message: err.message,
          debug: JSON.stringify(err)
        };
      }

      setLoginState({
        isAuthenticated: false,
        user: {},
        error: error
      });
    }
  };

  return (
    <div>
      <p>Display name: {loginState.user.displayName}</p>
      <p>Username: {loginState.user.userName}</p>
      <p>First name: {loginState.user.givenName}</p>
      <p>Last name: {loginState.user.surname}</p>
      {loginState.error ? <p>loginState.error</p> : null}
      {loginState.isAuthenticated ? (
        <div>
          <h4>Welcome {loginState.user.displayName}!</h4>
          <button color="primary" onClick={logout}>
            Logout
          </button>
        </div>
      ) : (
        <button color="primary" onClick={login}>
          Click here to sign in
        </button>
      )}
    </div>
  );
}

export default App;

Step 3: Running the application.

npm start

Be aware you would get a warning while running this application:

Compiled with warnings.

./src/App.js
  Line 35:6:  React Hook useEffect has missing dependencies: 'getUserProfile' and 'userAgentApplication'. Either include them or remove the dependency array  react-hooks/exhaustive-deps

Search for the keywords to learn more about each warning.
To ignore, add // eslint-disable-next-line to the line before.

The reason for this warning is the code is using getUserProfile and userAgentApplication inside the useEffect. You can read more about it here or you can add the eslint to ignore it.

Image 1: Before login

Image 2: Login would take to the Azure login page

Image 3: You might see different page of your organization login process and first time would see the contest pages to allow access.

Image 4: Then get redirected to the application.

Image 5: If you have logged in with more than one account it would ask which one to logout.

Learning Dapr: Simple Dotnet Core "Hello World"

Mohsen Kokabi — Thu, 06 Feb 2020 04:56:39 +0000

Dapr is an event-driven, portable runtime for building microservices on cloud and edge.
There is a Hello World sample in the documentation of Dapr but it's using node and python and persisting the state. While, it's showcasing the capabilities of Dapr but it might be too much for start.

Here in few step I would present a minimized version:

Step 1. Creating a dotnet web api and adding Dapr.

dotnet new webapi -o dapr.sample.webapi
cd .\dapr.sample.webapi\
dotnet add package Dapr.AspNetCore --version 0.3.0-preview01

In startup.cs:
in ConfigureService method

            services.AddControllers().AddDapr();

and in Configure method before MapControllers()

    endpoints.MapSubscribeHandler();

As I have another application running on my port 5000. I have to modify my launchSettings.json.

"applicationUrl": "http://localhost:5020"

Add this controller

using Dapr;
using Microsoft.AspNetCore.Mvc;
using System;

namespace dapr.sample.webapi.Controllers
{
    [ApiController]
    public class SampleController : ControllerBase
    {
        [Topic("hello")]
        [HttpGet("hello")]
        public ActionResult<string> Get()
        {
            Console.WriteLine("Hello, World.");
            return "World";
        }
    }
}

Step 2: Running the application

Make sure you are in the project folder. Then run:

dapr run --app-id sample --app-port 5020 --port 5030 dotnet run

Note: The app-id can be anything but you need it to invoke the methods through Dapr.

Now your application should be running on port 5020 while dapr is running on port 5030.

Step 3: Testing the application

First let's test the application itself:

curl http://127.0.0.1:5020/hello

should show in the same window

World

and in the dapr running window should show:

== APP == Hello, World.

Step 5: Testing Dapr

Now we can test dapr

curl http://localhost:5030/v1.0/invoke/sample/method/hello

which should have the same output in both windows.
the sample is the dapr app id and hello is the topic.

In addition to the invoke, dapr provides 2 other path as StatePath and PublishPath.

public const string StatePath = "/v1.0/state";
public const string InvokePath = "/v1.0/invoke";
public const string PublishPath = "/v1.0/publish";

We would show the former one but the later one is related to Pub/Sub invoke which would be in another post.

Part 2

Now, we are going to have the state persistent.

Add these to the controller:

        const string StateKey = "STATE_KEY";

        [Topic("add")]
        [HttpPost("add")]
        public async Task<ActionResult<int>> Add(
                        [FromBody]int x,
                        [FromServices] StateClient stateClient)
        {
            var state = await stateClient.GetStateEntryAsync<int?>(StateKey);
            state.Value ??= (int?)0;
            state.Value += x;
            await state.SaveAsync();

            return state.Value;
        }

restart the dapr and test it with powershell, postman or curl

Invoke-WebRequest -Uri 'http://127.0.0.1:5020/add' `
-ContentType application/json `
-Method Post `
-Body 1

The output would be like

StatusCode        : 200
StatusDescription : OK
Content           : 11
RawContent        : HTTP/1.1 200 OK
                    Transfer-Encoding: chunked
                    Content-Type: application/json; charset=utf-8
                    Date: Thu, 06 Feb 2020 04:47:14 GMT
                    Server: Kestrel

                    11
Forms             : {}
Headers           : {[Transfer-Encoding, chunked], [Content-Type, application/json; charset=utf-8], [Date, Thu, 06 Feb
                    2020 04:47:14 GMT], [Server, Kestrel]}
Images            : {}
InputFields       : {}
Links             : {}
ParsedHtml        : mshtml.HTMLDocumentClass
RawContentLength  : 2

Testing the dapr would be similar:

Invoke-WebRequest -Uri 'http://localhost:5030/v1.0/invoke/sample/method/add' `
-ContentType application/json `
-Method Post `
-Body 1

If we want to only get the state, we can call:

Invoke-WebRequest -Uri 'http://localhost:5030/v1.0/state/STATE_KEY' `
-Method Get

The STATE_KEY is the constant that we defined in the code.

Dependency Injection

The StateClient which was injected to the method, could be moved to the constructor:

        StateClient stateClient;
        public SampleController([FromServices] StateClient stateClient)
        {
            this.stateClient = stateClient;
        }

then it should be called with this

var state = await this.stateClient.GetStateEntryAsync<int?>(StateKey);

The source can be found in github

DotNet Core in kubernetes (Azure Container Registry)

Mohsen Kokabi — Tue, 04 Feb 2020 04:51:13 +0000

Here in simplest form we are going to run an Asp.Net core application in local Kubernetes.

Step 1: Creating a container registry

First you need to login to your azure account:

az login

if you don't know the id of the location you can get it with

az account list-locations

I am going to use australiaeast. So I am going to put it in a variable.

bash:

location='australiaeast'

powershell:

$location='australiaeast'

The other parameter I am going to need is a name for resource group
bash:

resource_group_name='ContainerRegistryRG'

powershell:

$resource_group_name='ContainerRegistryRG'

In case you are not using an existing resource group:

az group create --location $location --name $resource_group_name

Next parameter is a name for the container registry. As it needs to be unique I am adding the seconds from Unix Epoch.

bash:

crName=TestCR$(date +'%s')

powershell:

$crName='TestCR' + [int][double]::Parse((get-date -UFormat +%s))

Finally, we create the container registry:

az acr create -g $resource_group_name -n $crName --sku Basic --admin-enabled -l $location

I am going to (manually) store the value of loginServer from the json response in crServerName.

The next parameters we need are credentials.

az acr credential show -g $resource_group_name -n $crName

Take a note of "username" and password value

Step 2: Creating the docker image

Now we are going to create a dotnet core web application and build a docker image. The complete list is also here

dotnet new webapp -o KTestDotNetCoreWebApp

cd .\KTestDotNetCoreWebApp\

dotnet publish -c Release -o out

new-item -path "Dockerfile" -ItemType "file" -Value 'FROM mcr.microsoft.com/dotnet/core/aspnet:3.1-buster-slim AS runtime
WORKDIR /app 
COPY out ./ 
ENTRYPOINT ["dotnet", "KTestDotNetCoreWebApp.dll"]' 


docker build . -t ktest-dotnetcore-webapp-docker-image

We need to tag our docker image with the name of the container registry server.

docker tag ktest-dotnetcore-webapp-docker-image "$crServerName/ktest-dotnetcore-webapp-docker-image"

To be able to push to the registry you first need to login. You can login using either of following ways:

az acr login --name $crName --username $crName

docker login "$crServerName"

both of them will use the username and password you got using az acr credential show.

Now we can push our image:

docker push "$crServerName/ktest-dotnetcore-webapp-docker-image"

Step 3: using our docker image in Kubernetes

To allow kubernetes pull down our image, we need to define a image pull policy.
K8s would get the information it needs in a secret object. The type of this secret should be docker-registry. Here I am going to name it myregistrykey. It would be used while defining the container template either for the pod or for the deployment.

ref

kubectl create secret docker-registry myregistrykey --docker-server="https://$crServerName" --docker-username="$crName" --docker-password={replace the password} --docker-email=my@email.com

The password is what you get while running the az acr credential show
The email can be anything.

Now we are going to create a deployment object using kubectl run. As imagePullSecrets can not be added in the command line of creating the deployment object (or pod object), I would use --dry-run option with -o yaml to only generate the yaml.

kubectl run g5 --image="$crServerName/ktest-dotnetcore-webapp-docker-image:latest" --replicas=2 --port=80 --dry-run -o yaml >g5.yaml

Now, we need to add the imagePullSecrets at the same level of containers.

The final yaml would be like:

apiVersion: apps/v1
kind: Deployment
metadata:
  creationTimestamp: null
  labels:
    run: g5
  name: g5
spec:
  replicas: 1
  selector:
    matchLabels: 
      run: g5
  template:
    metadata:
      labels:
        run: g5
    spec:
      containers:
      - image: testcr{some numbers}.azurecr.io/ktest-dotnetcore-webapp-docker-image:latest
        name: g5
        ports:
          - containerPort: 80
      imagePullSecrets:
        - name: myregistrykey

And now we can create the deployment object using our yaml file.

kubectl apply -f g5.yaml

The last step is exposing the port 8080 using a load balancer service.

kubectl expose deployment g2 --type=LoadBalancer --name=glb --port=8080 --target-port=80

That's it. You can now browse the application on http://localhost:8080.

You might prefer to only create a pod. The only difference is add --restart=Never in kubectl run command and remove the --replicas:

kubectl run g3 --image="$crServerName/ktest-dotnetcore-webapp-docker-image:latest" --restart=Never --port=80 --dry-run -o yaml >g3.yaml

Similarly, edit the yaml file and add under spec add

      imagePullSecrets:
        - name: myregistrykey

and then create the object.

kubectl apply -f g3.yaml

The exposing step would be the same just saying pod instead of deployment.

kubectl expose pod g3 --type=LoadBalancer --name=glb --port=8080 --target-port=80

Simplest sample of DotNetCore in Docker

Mohsen Kokabi — Mon, 03 Feb 2020 04:42:27 +0000

Step 1 - create a DotNetCore web app

dotnet new webapp -o TestDotNetCoreWebApp

Step 2 - build

The way Visual Studio does this is

creating a build image docker
copy the project files there
making the build
copying the files back to your final image

here the purpose is to make it in the simplest form, so I am building locally.

cd .\TestDotNetCoreWebApp\

dotnet publish -c Release -o out

Step 3 - Create the docker image

First we need a docker file. You can use an editor but I am just using powershell.

new-item -path "Dockerfile" -ItemType "file" `
-Value 'FROM mcr.microsoft.com/dotnet/core/aspnet:3.1-buster-slim AS runtime
WORKDIR /app 
COPY out ./ 
ENTRYPOINT ["dotnet", "TestDotNetCoreWebApp.dll"]'

Build the image

docker build . -t test-dotnetcore-webapp-docker-image

Step 4

docker run -it --rm -p 8080:80 --name test-dotnetcore-webap-docker  test-dotnetcore-webapp-docker-image

the --rm option will tell docker engine to delete your docker as soon as it stopps.

Step 5

That's all. Your application is running on http://localhost:8080

if you run the docker ps in another terminal you would see your docker instance running but as soon as you stop it with Ctrl+C in the first terminal, the docker will be deleted.