ASP.NET Core and Docker for Beginner’s

Introduction:

Docker is an open, lightweight platform for developing, shipping and running applications using container technology. Docker provides container solutions for developers, architects, DevOps, and IT People. It can run on Linux, Windows, Mac OS and most the cloud providers like AWS, Azure, Google etc..

What is Docker?

Docker is all about running a single program inside separated environments. It is an open source platform with can be used to package, distribute and run applications in different environments.

Let start understanding by an example,


Applications 1 & 3 will stop working because they need a different framework to run. What can be done now? The above diagram shows, we have three applications running; however, all of the application use the same framework. What will happen if App 1 required different Framework version like 1.0, app 2 needs v2.0, app 3 needs v.3.0. As a result only App 2 will work because our framework installed is v2.0.

One way is to use three different systems for all three applications, but it will be very expensive and maintening them will also be very difficult.

This is how “DOCKER” comes into play. Docker will make sure each application has its own facilities rather than common facilities.

Docker will do something like this.


Build the ASP.Net Core and Docker Packages

Docker will create a package that can run in different environments.

To build an app in Docker, first we need an app to Dockerize.

Docker allows you to build an application in pretty much the same way you would create an application to run on your local machine.

When we create application make sure enable the Docker support and also make sure you have it installed by going to:

https://www.docker.com/products/docker-desktop

Note: Make sure Docker is installed .Otherwise you’ll get the below error:

Installing this (mac or pc) will run docker and allow you to create and host docker containers. Microsoft Visual Studio will use Docker Desktop to host your app inside of during development to allow you to develop or test in.

The trick is to get a new item in your launchSettings.json:

This, in conjunction with a docker file in your project (just called “Dockerfile” without an extension) that builds a container, hosts it, and allows you to debug it remotely.

Writing a Dockerfile:

What is Dockerfile?

In short, Dockerfile contains a series of instructions which define how to construct an image:

Below are the common commands:

FROM

This command specifies the base image, eg: Microsoft/aspnetcore:2.0

WORKDIR

Changes the working directory for subsequent instructions in the Dockerfile

COPY

Copies files from source to destination

RUN

Executes a command directly in the container

EXPOSE

Sets a specific port internally to the container

VOLUME

Usually, it is used to map a physical directory on our machine to the logical directory in the container instead.

ENTRYPOINT

Specifies which application will run in the container created from the image.

To use some of the commands, First create Dockerfile in your application:

Then write Dockerfile for ASP.NET Core app, you must first know if you want to use the Development Environment or the Production Environment.

In development environment you need an image that contains a compiler and allows compiling directly in the container, and for that, use Microsoft/aspnetcore-build directly from the DockerHub (Docker Repository).

In Production environment you do not need a compiler because it will have to build the application externally from the image, integrate all built files in the image, and just use a lightweight image containing the .NET Core Runtime Microsoft/aspnetcore to execute your application.

The Dockerfile is pretty simple (if you’re familiar with Docker) though it’s very automated, so you don’t have to know how it works:

It creates a container from a slim image with ASP.NET Core 2.2 , builds the project and publishes to get a copy of the project in a container. To test/debug with docker, just pick the ‘Docker’ option in the debugging dropdown:

After that, in cmd type:

docker build. –t rootandadmin/DockerApp –f Dockerfile

Now, you have your image and check the type:

docker images

You have your image rootandadmin/DockerApp but as this image is dead so you have to make it alive. For this you will need to create a container. There is a big difference between Image and Container; a container is a process that contains an image and executes it.

Then to create containers from our image type this.

docker create command –p 555:80 –name rootandadmin/DockerApp01 rootandadmin/DockerApp

docker start rootandadmin/ DockerApp01

You can try to access your DockeApp in the browser using the following address.

localhost://555/ DockerApp/Home

2019 – A year of Blogs

A year of Blogs ~ What we learned and looking ahead.

In 2019 the ECI marketing department rebuilt from the ground up and took on new initiatives in order to better serve our community, clients and employees.

We knew we had in our arsenal of talent some of the most successful and resourceful consultants in the industry, so with their help and a dedicated team of employees supporting their activities, ECI was able to publish weekly blogs around software development, project management and enterprise architecture.

Our most successful blogs of 2019 were:

Following your comments, activity we have learned what would be the areas of most interest for members of our community.

We have a variety of new blogs to be published from our team through out 2020, we are planning to be even more active and use the incredibly talented team we have to put out quality content on the regular.

You can follow our activity by signing up to our monthly newsletter on Estradaci.com

or by following us on TwitterFacebook, Linkedin and Medium!

We really look forward to hearing from you and cherish the time you take to comment and interact with our content.

ECI 2019 Year of Events Review

This year we TRAVELLED!

2019 was a year of revamping our marketing activity here at ECI! We rapidly increased our presence across events in North America. As the year went on, we met some of the most influential employees, CIO’s and contractors across Canada and the United States.

 

 

Where We Went

In 2019 we participated in many events across the United States and Canada, we focused our attention to the events where we could connect with influential people, learn and have an opportunity to showcase our incredible accomplishments.

  • State of Technology — California, USA
  • Azure Technical User Group — British Columbia, Canada
  • DotNet Technical User Group — British Columbia, Canada
  • CTOBC — Nevada, USA
  • Tableau Technical Group — California, USA
  • Tableau Technical Group — British Columbia, Canada
  • Oracle Technical Group — British Columbia, Canada
  • Data Science Expo — British Columbia, Canada
  • Microsoft Power BI — British Columbia, Canada
  • Seattle Reverse Vendor Trade Show — Washington, USA
  • Union of BC Municipalities — British Columbia, Canada

 

What We Learned

The year 2019 was a multi faceted year for ECI activities, it was the year the company entered and started operations in British Columbia, by setting up an office and putting together a team working out of Vancouver. Members of ECI attended and connected with many industry and government professionals to showcase and network around the incredible accomplishments of ECI.
Our consultants and developers learned about the state of technology in governments across the west coast of the United States and Canada.
Representation is key! As a part of ECI marketing activity we want to make it easy for governments and organizations to find us, speak to us and ask us questions. We know we have a strong arsenal of experience and contracts under our portfolio that contain years and years of valuable knowledge for individuals and organizations looking to expand and renew their public services.

 

 

Where We Will Be 2020

2019 was a busy year… 2020 will be busier, ECI Consultants and Executives will be attending multiple conferences, trade shows and government events to share our knowledge and meet the great people who work hard to make life better for the people of Canada and the United States.

Some of the events ECI members may be attending in 2020: 

  • TDWI — Las Vegas, Nevada
  • ConnectBC — Victoria, BC
  • Transit Initiatives and Communities Workshop — Sacramento, California
  • Excellence in Transportation Awards — Los Angeles, California
  • BC Transit Workshop 2020 — Vancouver, BC
  • Digital Government Summit — Sacramento, California
  • CES Government — Las Vegas — Nevada
  • Washington State Regional Contracting Forum — Seattle, Washington
  • BC Tech Impact Awards — Vancouver, Canada
  • BC Tech Summit — Vancouver, Canada
  • California CIO Awards — Sacramento, California

We look forward to seeing you & hearing from you.

If you know of an event or want to see us at one, make sure to send us an email, message or tweet at us.

RESTful API Designing Guidelines

Your introduction for everything REST and how to understand it.

What is REST?

Representational state transfer (REST) is a software architectural style that defines a set of constraints to
be used for creating Web services. Web services that conform to the REST architectural style, called
RESTful Web services, provide interoperability between computer systems on the Internet.

Terminologies

The following are the most important terms related to REST APIs:

Resource
Resource is an object or representation of something, which has some associated data with it and
can be set methods to operate on it.
E.G Company

Collections
Collections are a set of resources.
E.G Companies is the collection of the Company Resource.

URL
URL (Uniform Resource Locator) is a path through which a resource can be located and actions can
be performed on it.

API Endpoint
In simple terms, an API endpoint is the point of entry in a communication channel where two systems are
interacting. It refers to a touch point of communication between an API and the server.
The location where the API sends a request and where the response emanates is what is known as an
endpoint.

API vs Endpoint
An API refers to a set of protocols and tools that allow interaction between two different applications. It is a technique that enables third-party vendors to write programs that can easily interface with each other. On the other hand, an endpoint is the place of interaction between applications. API refers to the whole set of protocols that allows communication between two systems while an endpoint is a URL that enables the API to gain access to resources on a server.

Web Api Endpoint Naming Convention

Methods Naming Convention
In OOP methods are named with verbs to make it easier to identify what operation that method will
perform, for example the method GetEmployees(int departmentID) will return all the employees that
belongs to a department.

Should we use the same naming convention when designing web Api’s endpoints?
The answer is NO.
Web Api endpoints must be names with NOUNS instead of verbs and it should contain the plural form of
the Resource the api will perform operations on.

Example: https://www.estradaci.com/apis/v1/Employees

If the URL can’t contain verbs, how do we know which action will be performed?
HTTP Verbs will be responsible for telling which action the WEB API should perform.
Let’s look at the most used HTTP Verbs used while creating WEB APIs.

HTTP VERBS.

GET
Use GET requests to retrieve resource representation/information only – and not to modify it in any
way. As GET requests do not change the state of the resource, these are said to be safe methods.
Additionally, GET APIs should be idempotent, which means that making multiple identical requests must
produce the same result every time until another API (POST or PUT) has changed the state of the
resource on the server.

Examples:
 GET https://www.estradaci.com/apis/v1/Employees
 GET https://www.estradaci.com/apis/v1/Employees/1
 GET https://www.estradaci.com/apis/v1/Employees?name=Jeff
All the endpoints above will fetch employees but using different inputs to query the employees.

HTTP POST
Use POST APIs to create new subordinate resources, e.g. a file is subordinate to a directory containing it
or a row is subordinate to a database table. Talking strictly in terms of REST, POST methods are used to
create a new resource into the collection of resources.
Examples:
 POST https://www.estradaci.com/apis/v1/Employees
 POST https://www.estradaci.com/apis/v1/Employees/Address

Both endpoints above will insert data in the database, the first one will create a new employee and the
second one will create an address for an employee.

HTTP PUT
Use PUT APIs primarily to update existing resource (if the resource does not exist then API may decide to
create a new resource or not). If a new resource has been created by the PUT API, the origin server
MUST inform the user agent via the HTTP response code 201 (Created) response and if an existing
resource is modified, either the 200 (OK) or 204 (No Content) response codes SHOULD be sent to
indicate successful completion of the request.
Examples:
 PUT https://www.estradaci.com/apis/v1/Employees
 PUT https://www.estradaci.com/apis/v1/Employees/Address

Both endpoints above will update data in the database, the first one will update an employee and the
second one will update the employee`s address.

HTTP DELETE
As the name applies, DELETE APIs are used to delete resources (identified by the Request-URI).
Examples:
 DELETE https://www.estradaci.com/apis/v1/Employees
 DELETE https://www.estradaci.com/apis/v1/Employees/Address

Both endpoints above will delete data from the database, the first one will delete an employee and the
second one will delete the employee`s address.
As we can see the same URL can perform different actions when requested with different HTTP Verbs.

For example the https://www.estradaci.com/apis/v1/Employees can Get, Create, Update and Delete
employees based on the HTTP Verb used.

HTTP response status codes

Sometimes when the client sends a request to the server it expects a response indicating the result of the
operation. it’s a good practice to return coherent status codes to make it easy to the client understand what
happened when the request is processed.
HTTP defines standard status codes that can be used to convey the results of a client’s request. The
status codes are divided into the five categories presented below.

CATEGORY DESCRIPTION

1xx: Informational Communicates transfer protocol-level information.

2xx: Success Indicates that the client’s request was accepted successfully.

3xx: Redirection Indicates that the client must take some additional action in order to complete their request.

4xx: Client Error This category of error status codes points the finger at clients.

5xx: Server Error The server takes responsibility for these error status codes.

Check below the description of the most used Status Codes used when creating a web api.

For a complete list of the HTTP Status Codes check https://docs.microsoft.com/en-
us/dotnet/api/system.net.httpstatuscode?view=netframework-4.8

200 (OK)
It indicates that the REST API successfully carried out whatever action the client requested, and that no
more specific code in the 2xx series is appropriate.

201 (Created)
A REST API responds with the 201 status code whenever a resource is created inside a collection. There
may also be times when a new resource is created as a result of some controller action, in which case
201 would also be an appropriate response.

204 (No Content)
The 204 status code is usually sent out in response to a PUT, POST, or DELETE request when the REST
API declines to send back any status message or representation in the response message’s body.
An API may also send 204 in conjunction with a GET request to indicate that the requested resource
exists, but has no state representation to include in the body.

304 (Not Modified)
This status code is similar to 204 (“No Content”) in that the response body must be empty. The key
distinction is that 204 is used when there is nothing to send in the body, whereas 304 is used when the
resource has not been modified since the version specified by the request headers If-Modified-Since or
If-None-Match.

400 (Bad Request)
400 is the generic client-side error status, used when no other 4xx error code is appropriate. Errors can
be like malformed request syntax, invalid request message parameters, or deceptive request routing
etc.
The client SHOULD NOT repeat the request without modifications.

401 (Unauthorized)
A 401 error response indicates that the client tried to operate on a protected resource without providing
the proper authorization. It may have provided the wrong credentials or none at all.

404 (Not Found)
The 404 error status code indicates that the REST API can’t map the client’s URI to a resource but may
be available in the future. Subsequent requests by the client are permissible.

500 (Internal Server Error)
500 is the generic REST API error response. Most web frameworks automatically respond with this
response status code whenever they execute some request handler code that raises an exception.

Content Negotiation

When sending a request to an API we need to tell the server what is the type of the data we are sending
and the server is responsible to tell the client the same.

At server side, an incoming request may have an entity attached to it. To determine it’s type, server
uses the HTTP request header Content-Type.

Some common examples of content types are :“text/plain”, “application/xml”, “text/html”, “application/json”, “image/gif”, and “image/jpeg”.

Content-Type: application/json
Similarly, to determine what type of representation is desired at client side, HTTP header ACCEPT is
used. It will have one of the values as mentioned for Content-Type above.
Accept: application/json

The most used content-type used by APIS to represent the object the is being sent to the server or
returned to the client is JSON, make sure to use the camelCase naming convention when using JSON.

API Versioning
One of the most important things in WEB API development is the versioning.
WEB APIs must be well versioned in order to prevent the clients that are consuming it to break.

When a Break Change is made to an existing WEB API, instead of modifying the existing one we must
create a new version of it.

For example:
Several changes are required to be made on the WEB API
https://www.estradaci.com/apis/v1/Employees and these changes may lead the consumers to break
their integrations.
Instead of simply applying the changes to this API we need to create a new version of the api, E.G
https://www.estradaci.com/apis/v2/Employees.
This will prevent the clients that are consuming the V1 to break and will give them the time and
flexibility to migrate their calls to the V2.

REST vs. gRPC – The Battle Over Service Orientation

Rest Vs. gRPC

Services are a common talk between developers and companies that are in the process of implementing software; they are an important piece in any project architecture as they separate layers of functionality and offer the flexibility of implementing different levels of security in between layers. Their implementation can vary from serving data from the database servers, sending messages to other servers, and much more.

In .NET technologies there used to exist an entire framework dedicated to services and Windows Communication Foundation, this collection of tools would help set up services in a variety of protocols. On the downside, they were closely coupled with .NET, making the configuration of services more complex than some of the most popular options of its time.

Then came REST, a new portable way of communicating clients and servers via TCP, making them accessible over the internet. Most of the big web sites implement REST APIs to provide information to the outside world (such as Google, Twitter, LinkedIn, etc.). This model is based on Request-Response model that will return a text-based response (JSON, XML, HTML), currently the standard is JSON (JavaScript Object Notation). This is a flexible way to work with objects without depending on the platform.

The Problem…

The problem with JSON comes when you have a high demand application (server or client) that will make a large amount of request/responses. If you have to serialize/deserialize the objects to your native types, it will add an extra conversion overhead. If you are not having a outword facing application, you mostly have the same technologies applied in both sides of the communication, meaning that the service will have to take the response object from C#, serialize it to JSON and send it back to the client. Then the client will take the response JSON and deserialize back to your C# object. This is by no means hard to achieve, but the processing time may be impacted by the workload of your application.

There is a solution!

To solve this, we have RPC (Remote Procedure Call). This communication is based on Protocol Buffers, a mechanism to serialize data (the data is serialized in raw format). It offers all the main functionalities that REST does, with the added option for bidirectional streams that allow the client and server to communicate asynchronously that result in faster times. The configuration steps to get a gRPC service may seem a little more complex and limited than REST (Protocol Buffers currently supports generated code in C++, Go, Java, Phyton, Ruby and C#), but the benefit of faster performance may compensate.

In conclusion.

Current implementation of services using gRPC came with the adoption of Cloud computing and microservices with high performance demand. So, if you are planning create or enhance a service take a look at the past first, then present technologies and the future of your implementation in order to make the correct call. In conclusion, REST is still the most simple and portable solution if you don’t have an issue with communication performance.

If you want to know more about gRPC go to https://grpc.io/docs/guides/

1 2 3 8