Chapter 5 - Understanding HTTP Protocols and REST APIs
Published: 2023-09-28 00:00:15


## Chapter 5 - Understanding HTTP Protocols and REST APIs

### Building our first webservice with Go (Part 2)

![img](https://cdn-images-1.medium.com/max/2048/1*jS9JMUs3EjqDLS8pCFcIUw.jpeg)

The following list is the previous chapters of this series:

* [Chapter 1 — Introduction to Microservices](https://dev.to/josueparra2892/chapter-1-introduction-to-microservices-5a2c)

* [Chapter 2 — Introduction to Microservices (Part 2)](https://dev.to/josueparra2892/chapter-2-introduction-to-microservices-part-2-479l)

* [Chapter-3 Domain-driven design and microservices](https://dev.to/josueparra2892/chapter-3-domain-driven-design-and-microservices-371b)

* [Chapter -4 Advantages of using Go for web development](https://dev.to/josueparra2892/chapter-4-advantages-of-using-go-for-web-development-4b0k)

I recommend you take a look at the previous chapters if you have not read them yet. That will help you to get more knowledge in this wonderful world of “Microservices architecture”.

## Structure

In this chapter, the following topics will be covered:

* Understanding HTTP protocols

* Understanding the request-response model in HTTP

* Understanding the Purpose of Different HTTP Methods GET, POST, PUT, and DELETE

* Understanding REST APIs

* Best practices to define our APIs

## **Understanding HTTP protocol**

In the realm of software development, particularly in web development, “HTTP protocols” stand as a fundamental pillar. This concept plays a vital role in facilitating communication between clients and servers, making it crucial to comprehend how data is transmitted and interactions are executed on the web. Thus, learning about these protocols becomes an essential aspect of understanding web development.

In this topic, we will delve into the characteristics and usage of HTTP protocols, placing special emphasis on the request-response model that serves as the foundation of this architecture. Gaining a thorough understanding of how requests and responses are established and managed is of utmost importance in the development of efficient and effective web applications.

Throughout this chapter, we will explore another crucial aspect related to HTTP methods, including GET, POST, PUT, and DELETE. By delving into their specific purposes and use cases, we aim to shed light on the fundamental roles they play in client-server interaction. Understanding how each method operates empowers developers to create more versatile and capable web applications.

### **Understanding the request-response model in HTTP**

The HTTP request-response model plays a pivotal role in facilitating communication between web components, acting as clients and servers. When a client sends an HTTP request to the server, the latter responds with the requested data or confirms the result of the action required. This approach ensures a seamless and efficient interaction between users and online systems, enhancing the overall user experience.

Figure 2.1 shows how this communication flow is established. There the client is the web application and the server is one of the microservices defined for an e-commerce system.

![***Figure 2.1**: request-response model*](https://cdn-images-1.medium.com/max/3200/0*RYSKkwOfBvAJH-dI)

To gain a deeper understanding of how this model operates, let’s analyze each step involved, from the initial request to the final response. By delving into the intricacies of each stage, can be uncovered the underlying mechanics that enable a smooth flow of communication between clients and microservices.

When a client needs to access a resource, be it a web page, a file, or a microservice that will respond, it initiates the process by sending an HTTP request to the server. This request contains the address or URL of the specific resource it requires access to. Depending on the nature of the operation, the request can take various forms, such as a GET method to retrieve information, a POST method to send data to the server, a PUT method to update an existing resource, or a DELETE method to remove a resource.

If you have any concerns or doubts about these HTTP methods, rest assured that we will explore each of them in detail later in this chapter. By gaining a thorough understanding of how each method functions, you’ll be well-equipped to make use of them effectively in your web development and microservices projects.

Once the server receives the client’s request, it proceeds to process the request and searches for the requested resource. If the resource is found, the server generates an HTTP response containing the requested data or a confirmation of the action’s outcome. Additionally, the response includes an HTTP status code that signifies the success of the request or indicates if an error has occurred during the process. This status code provides valuable information to the client, enabling it to interpret and handle the response appropriately based on the result of the operation.

Upon receiving the server’s response, the client proceeds to process the data or information provided. If the response contains HTML code, as is the case with web pages, the browser interprets the received code and renders the page for the user to view. On the other hand, when the client consumes a microservice, it extracts and utilizes the data that was requested during the initial request. This data can then be further processed or presented to the user, depending on the specific needs of the client application. This seamless exchange of data between client and server enables efficient data transfer in microservices-based systems.

Figure 2.2 shows the flow described above there can be seen the interaction between the client and server as well as the different methods in action.

![***Figure 2.2**: request-response complete interaction between client and server.*](https://cdn-images-1.medium.com/max/3200/0*u8foe0acN2tqA63g)

The request-response model plays a vital role in enabling efficient interaction between users and online systems. By adhering to this approach, users can seamlessly access the information and resources they require, leading to a smooth and user-friendly experience. The widespread adoption of this model has paved the way for the development of a diverse array of applications and services that enrich our daily lives on the web. Its effectiveness in facilitating real-time communication between clients and servers has revolutionized the way we interact with digital platforms, empowering us to navigate the vast expanse of the internet with ease and convenience.

As mentioned earlier, the request-response model involves two essential components: the client and the server. To ensure its proper functionality, certain key elements are necessary. Let’s delve into each of these elements in the following sections.

### **Key elements for client-side**

**Method**
Indicates the type of action to be performed on the server. The most common methods are GET, POST, PUT, and DELETE, among others. Each method has a specific purpose and is intended to perform particular actions on the server.

**URL (Uniform Resource Locator)
**It is the address that identifies the resource that the client wishes to access or manipulate on the server. It can be a web page, a file, a service, or any other resource available on the server.

**Headers
**These are metadata that provide additional information about the request, such as customer information, content preferences, or cookies.

**Request Body (Optional depending on the method)
**Certain HTTP methods, such as POST and PUT, provide the capability to include additional data within the request body. This feature is particularly useful for transmitting data from the client to the server, especially when performing operations that require data submission.
As developers, we must carefully handle and process data received in the request body to ensure data integrity and security. Proper validation and parsing of the request body data are essential to prevent security vulnerabilities and ensure that the server processes the information accurately.
For example, when a user submits a form on a web page, the form data is typically included in the body of a POST request. The data within the request body can be in various formats, such as JSON, XML, or form-encoded data, depending on the application’s requirements.

### **Key elements for server-side**

**Status Code
**The status code is a three-digit number that communicates the outcome of the request. It serves as a standardized way for servers to convey the result of a client’s request. Some common status codes include:

* **200 OK**: Signifies a successful request, indicating that the server has fulfilled the client’s request.

* **404 Not Found**: Indicates that the requested resource could not be found on the server.

* **500 Internal Server Error**: Points to an error on the server’s side, indicating that something went wrong while processing the request.

Status codes provide valuable information to clients about the success or failure of their requests, enabling them to react accordingly. A wide range of status codes caters to various scenarios, facilitating effective communication between clients and servers in the HTTP protocol. As developers, understanding and interpreting these status codes is crucial for troubleshooting and providing meaningful feedback to users about the status of their requests.

**Headers
**Similar to the request, the response can also include headers that offer additional information about the request result or the content being returned. Headers play a vital role in providing crucial metadata, such as content type, cache control, authentication details, and more, which help both the client and server understand and process the response effectively. Utilizing headers appropriately enhances communication and enables seamless handling of data between the client and server.

**Response Body
**The response body plays a crucial role in delivering the actual content and data to the client, enabling the user interface to render the information appropriately. When a client sends a request, the server processes the request and generates the appropriate response, encapsulating the desired information within the response body.

As developers, we carefully construct the response body to ensure it accurately reflects the client’s request, delivering the expected content in a well-structured and organized format.

For instance, if the client requested a web page, the response body would contain the HTML code representing the content of that page. Similarly, for API requests, the response body could contain JSON or XML data containing the requested information.

The request-response model is a crucial concept in web communication, playing a fundamental role in the interaction between clients and servers through the HTTP protocol. It establishes a standard and well-defined structure for communication between systems, enabling efficient and consistent data transfer.

Through skillful application of this model, developers can create efficient, scalable, and reliable systems that cater to evolving user demands and provide an exceptional user experience in the vast and dynamic world of the web.

## **Understanding the Purpose of Different HTTP Methods**

![img](https://cdn-images-1.medium.com/max/3684/1*_s_nJBkqn5hfMVIPeSWZcQ.png)

Before we delve into HTTP methods, let’s take a moment to review their origin and historical development over the years. Understanding the evolution of these methods provides valuable insights into how they have been refined and adapted to meet the changing needs of web development and communication between clients and servers.

HTTP methods have their origin in the development of the HTTP protocol (Hypertext Transfer Protocol), which was proposed by Tim Berners-Lee in 1989 and formalized by the World Wide Web Consortium (W3C) in 1991. The HTTP protocol was born to facilitate communication and data exchange between clients and servers in the emerging World Wide Web.

In its early days, the web consisted primarily of text documents, and the HTTP protocol allowed the transfer of these documents between the servers that stored them and the web browsers that requested them. As the web began to grow and become more complex, it was necessary to define a series of standardized actions to achieve a more sophisticated interaction with the servers. This evolution of the web and the need to cover this need gave rise to the HTTP methods, which from that moment became the fundamental verbs of the protocol, defining the operations that clients could carry out on web resources. Thanks to the global standardization and adoption of the HTTP protocol and its methods, the web has experienced exponential growth and has become a universal platform for accessing and distributing information around the world.

Throughout this period and evolution, it has gone from only having traditional methods such as GET and POST, to a complete switch to which methods such as PUT, DELETE, and PATCH were added, expanding the possibilities of interaction and operations between client-servers. Even today, HTTP methods continue to be an essential part of web communication and have evolved to fit today’s needs.

Now that we have gained insights into the origins of HTTP methods, let’s proceed to define and analyze each one of them in detail.

The HTTP methods, often referred to as verbs or actions, play a crucial role in conveying the client’s intent when requesting a web server. These methods serve to define the operations that can be performed on resources identified by their URLs (Uniform Resource Locators).

Each HTTP method represents a distinct set of actions that clients can undertake on web resources, facilitating diverse interactions between applications and servers across the web. With each method having well-defined semantics and usage, web applications can communicate consistently and coherently throughout the vast World Wide Web environment. This commitment to well-established methods ensures a seamless exchange of information between clients and servers, promoting robust interoperability.

**The HTTP methods available for use are as follows:**

* GET

* POST

* PUT

* DELETE

* HEAD

* OPTIONS

* PATCH

* TRACE

### **GET Method**

The GET method holds a fundamental place among the verbs in the HTTP (Hypertext Transfer Protocol) protocol, representing one of the most common actions that clients can take when interacting with web servers. As a cornerstone of web communication, the GET method allows clients to retrieve information and resources from servers, playing a pivotal role in enabling seamless data access and content delivery across the World Wide Web.

The GET request is considered idempotent, which signifies that making multiple identical GET requests to the same resource does not result in any side effects on the server or alter the resource’s state. Consequently, the server should consistently respond in the same manner to each of these identical GET requests, ensuring predictability and consistency in the retrieval of information from the resource.

The idempotent nature and absence of side effects make the GET method a safe and reliable option for retrieving information from web servers. Whether it’s fetching a web page, an image file, a JSON document, or any other resource identified by a URL (Uniform Resource Locator), the GET method plays a crucial role in facilitating the exchange of information that occurs daily on the Internet. Its widespread use and reliability have made it an essential part of modern web communication, empowering users to access a diverse range of resources with confidence and ease.

**Key features of the GET method:**

* **Data Request
**As mentioned the main purpose of this method is to obtain data from the server. For example, when a user clicks a link or enters a URL in the browser, a GET request is made to retrieve the content associated with that URL.

* **Query Parameters
**A GET request can include query parameters as part of the URL to specify additional criteria or details about the request.
For example, when performing a search, the search criteria can be included in the URL as query parameters.

* **URL Visibility
**Since the query parameters are included in the URL, the GET request is visible, which means that the data sent in the GET request can be exposed, so it is not recommended to use it to transmit sensitive information.

* **Security
**Since GET requests are visible in the URL and may be recorded in server logs or browser history, they should not be used to send sensitive or confidential data, as they could be accessible to unauthorized third parties.

* **Browser Cache
**Due to its idempotent nature and no side effects, browsers tend to cache responses from GET requests.

### **POST Method**

The POST method is another fundamental verb in the HTTP (Hypertext Transfer Protocol) protocol, playing a crucial role in facilitating the exchange of data between clients and servers. Unlike the GET method, which is primarily used to retrieve data from a resource, the POST method is designed to send data to the server for processing. This enables clients to perform actions that modify the state of resources on the server.

The non-idempotent nature of the POST method, combined with its capability to include data in the request body, renders it suitable for a wide range of tasks. These include creating new resources, submitting forms, and transmitting sensitive information securely to the server. By leveraging the POST method, web applications can achieve complex interactions and enable users to submit data seamlessly, contributing to a rich and interactive user experience.

When a client sends a POST request to a server, the data is included in the request body, distinguishing it from the GET method, where data is part of the URL. The POST request can contain a diverse range of information from submitting user inputs to uploading files or transmitting complex data structures, such as form data, user data, attachments, and other structured data in various formats like JSON or XML.

By utilizing the POST method, web applications can efficiently interact with servers and facilitate sophisticated data exchanges that contribute to a dynamic and responsive user experience.

**Key features of the POST method:**

* **Sending Data
**The main purpose of the POST method is to send data to the server for processing. For example, when submitting a form on a website, the data entered by the user is sent to the server via a POST request for processing.

* **Data in the Request Body
**Unlike GET, where the data is included in the URL, in POST the data is sent in the body of the HTTP request. This allows you to send larger amounts of more complex data in a structured way.

* **Resource Creation
**The POST method is commonly used to send data that will create new resources on the server. For example, when publishing a new product, a POST request is made to submit the product details and create a new entry in the server’s database.

* **Request Length
**The length of the data sent in the POST request can be considerably longer compared to GET requests, which are generally limited in length due to the query parameters that are included in the URL.

* **Not idempotent
**Unlike the GET method, the POST method is not idempotent, which means that making the same POST request multiple times can have different effects or change the state of the resource on the server. For example, if a POST request is sent to create a new resource, each request will create a new resource with an identifier that makes it different from the others.

* **Security
**Since the data is sent in the request body and is not visible in the URL, the POST method provides an additional layer of security compared to GET. This makes it suitable for sending sensitive data, such as passwords or credit card information since the data is not exposed in the browser’s address bar.

### **PUT Method**

The PUT method is another fundamental verb in the HTTP (Hypertext Transfer Protocol) protocol. Its primary purpose is to transmit data from the client to the server to update or replace an existing resource on the server. In contrast to the POST method, which is used for creating new resources, the PUT method is specifically designed for modifying existing data on the server.

By leveraging the PUT method, clients can efficiently update or replace resource representations, ensuring data accuracy and consistency in web applications and systems. This method plays a crucial role in enabling effective resource management and facilitating seamless interactions between clients and servers in HTTP.

It is idempotent, which ensures that making multiple identical PUT requests has no additional side effects beyond updating the resource. The PUT method is essential for web applications that require the ability to modify existing data and maintain the integrity of resources on the server.

**Key features of the PUT method**

* **Resources Update
**The main purpose of the PUT method is to update or replace an existing resource on the server with new data provided by the client. For example, a customer can use the PUT method to update user profile information, modify shipping addresses, or update product stock.

* **Resource Identification
**To make a PUT request, the client must provide the URL of the specific resource that it wants to update. The server uses this URL to identify the resource to be modified, the identifier should be part of the URL.

* **Data in the Request Body
**The PUT is similar to POST request, in PUT the data is sent in the body of the HTTP request. This allows you to send larger amounts of more complex data in a structured way that will be used to update the existing values.

* **Idempotence
**Like the GET method, the PUT method is idempotent, which means that making an identical PUT request to the same resource multiple times should have no additional side effects beyond updating the resource with the new data provided. Each identical PUT request updates the resource with the same data.

* **No Browser Cache
**Like the POST method, browsers generally do not cache responses from PUT requests, as they can have side effects on the server, changing the state of an existing resource.

* **Security
**As with any HTTP method, it’s important to keep security considerations in mind when using PUT. PUT requests can have a significant impact on data on the server, so it is critical to apply proper authentication and authorization mechanisms to protect resources from unauthorized modification.

* **Not Visible in URL
**Like the POST method, the data sent with the PUT method is not visible in the URL. The data is sent in the body of the HTTP request, providing greater privacy and security for the transmission of information.

### **PATCH Method**

The PATCH method is another essential verb in the HTTP (Hypertext Transfer Protocol) protocol, enabling the client to send data to the server to apply partial modifications to an existing resource.

In contrast to the PUT method, which is utilized to entirely update or replace a resource, the PATCH method offers the flexibility to make partial or specific changes to the content of the resource. This targeted approach allows developers to modify specific attributes or sections of a resource without the need to send the entire representation, thus optimizing the data exchange process.

The PATCH method is particularly valuable in scenarios where resources are extensive, and only specific updates are required. By leveraging the PATCH method, web applications can efficiently manage resource updates, minimizing data transfer and reducing the chances of conflicting modifications from multiple clients. This granular control over resource updates enhances the efficiency and responsiveness of web services, contributing to a smoother user experience and streamlined resource management on the server.

**Key features of the PATCH method:**

* **Partial Modifications
**The main purpose of the PATCH method is to apply partial or specific changes to the content of a resource on the server. This means that instead of sending all of the resource data in the request, the client only sends the changes or updates that you want to make to the existing resource.

* **Resource Identification
**Similar to the PUT and POST methods, to make a PATCH request, the client must provide the URL of the specific resource that it wants to modify, where the identifier is part of that URL.

* **Idempotence
**Although the PATCH method is not guaranteed to be idempotent by default, it can be designed to be idempotent if the server is configured to do so. This means that when making multiple identical PATCH requests to the same resource, the result should be the same, and no additional side effects should be applied.

* **Security
**As with any HTTP method, it is important to be aware of security when using PATCH. Since PATCH can modify only a specific part of the resource, it is essential to apply proper authentication and authorization mechanisms to protect resources from unauthorized modification.

* **Not Visible in URL
**As with the POST and PUT methods, the data sent with the PATCH method is not visible in the URL.

* **Data in the Request Body
**Changes are sent in the body of the HTTP request, providing greater privacy and security for the transmission of information.

* **No Browser Cache
**Like the POST and PUT methods, responses from PATCH requests are generally not cached by browsers, as they can have side effects on the server, partially modifying the state of an existing resource.

### **DELETE Method**

The DELETE method is another vital verb in the HTTP (Hypertext Transfer Protocol) protocol, serving as a means to request the deletion of a specific resource on the server. Its primary purpose is to instruct the server to remove the designated resource from its storage.

As the method specifically intended for deleting resources on the web server, the DELETE method plays a crucial role in managing and maintaining the state of resources in web applications. By utilizing the DELETE method, clients can efficiently initiate the removal of unnecessary or obsolete data, promoting efficient resource management and data cleanup on the server.

This capability is especially valuable for applications that handle user-generated content, data archiving, or any scenario where the removal of resources is required to maintain system performance and data integrity. The DELETE method’s well-defined purpose and standardized implementation enable developers to design robust and secure systems, ensuring the appropriate handling of resource deletions and enhancing the overall functionality of web applications.

**Key features of the DELETE method:**

* **Resource Removal
**The main purpose of the DELETE method is to delete a specific resource on the server. When a client sends a DELETE request it is telling the server to delete the resource associated with that URL, that resource is associated with a unique identifier.

* **Idempotence
**Like the GET method, the DELETE method is also idempotent. This means that making multiple identical DELETE requests to the same resource has no additional side effects beyond deleting the resource once.

* **Security
**Since the DELETE method involves a destructive action on the server, it is essential to apply proper authentication and authorization mechanisms to protect resources from unauthorized deletion.

* **No Browser Cache
**Like the POST, PUT, and PATCH methods, browsers generally do not cache responses to DELETE requests, since a deleted item is typically no longer accessible to users.

### **HEAD Method**

The HEAD method is one of the helper verbs in the HTTP (Hypertext Transfer Protocol) protocol, this verb is very similar to the GET method. However, the HEAD method is used to request only the headers of an HTTP response, not including the message body. In other words, the HEAD method allows a client to get information about a resource without downloading all of its content, making it useful for performing quick availability checks, getting metadata information, or validating the existence of a resource.

By its nature the HEAD method is a lightweight alternative to the GET method, ideal for checking the availability of a resource, obtaining metadata information, and performing quick checks on the existence of resources without downloading all their content. Its idempotency and efficiency make it a valuable option in certain scenarios where the client needs limited information about a resource.

**Key features of the HEAD method:**

* **Getting Headers
**The main purpose of the HEAD method is to get the headers of an HTTP response without receiving the response body, these headers may contain important information about the resource.

* **light response
**The HEAD method is especially useful when the client only needs to get information about the resource without downloading all the content.

* **Resource Identification
**Like the other HTTP verbs that have been reviewed, the client must provide the URL of the specific resource from which it wants to get the headers. The server uses this URL to identify the resource and generate a response with the requested headers.

* **Idempotence
**Like the GET and DELETE methods, the HEAD method is also idempotent. Making multiple identical HEAD requests to the same resource has no additional side effects, and the server must provide the same headers in response to repeated requests.

### **OPTIONS Method**

The OPTIONS method is one of the verbs in the HTTP (Hypertext Transfer Protocol) protocol. This is used to obtain information about the options and capabilities that are supported by a specific resource on the server, its main purpose being to provide a clear and detailed description of the options allowed for a resource without making requests that have side effects on the server.

The OPTIONS method is considered as a non-standard request and is mainly used to allow clients to obtain details about the functionality and configurations supported by a server, which can be useful for interoperability and service discovery in complex web applications.

**Key features of the OPTIONS method**

* **Informative Response
**The response to an OPTIONS request contains information in the form of HTTP headers indicating the options supported by the server for the requested resource. These headers include “Allow”, which lists the allowed HTTP methods, and other custom headers that the server can include to provide additional details.

* **Resource Identification
**As with the other HTTP methods, the client must provide the URL of the specific resource from which it wishes to obtain the options. The server uses this URL to identify the resource and generate a response with the requested information.

* **No Browser Cache
**Like the HEAD and DELETE methods, browsers generally do not cache responses from OPTIONS requests, as this information can change and is required for real-time interaction with the server.

### **TRACE Method**

The TRACE method is one of the verbs in the HTTP (Hypertext Transfer Protocol) protocol, primarily employed for diagnostic and debugging purposes. Its main function is to enable clients to obtain a “trace” of the route a request takes from the client to the server and back, including all intermediaries (proxies) encountered along the way.

This feature proves useful for tracing the path of a request through various servers and proxies to verify the integrity and routing of the requests. However, due to its potential for vulnerabilities, many servers disabled support for the TRACE method by default for security reasons.

## **Understanding REST APIs**

![img](https://cdn-images-1.medium.com/max/5120/0*rKhhXGsN2ZaCrmif.jpg)

In the world of software development, more specifically in web development, “REST-based Application Programming Interfaces” (REST APIs) have revolutionized the way applications and services communicate and interact with each other. Since their inception, REST APIs have become a fundamental pillar for the creation of applications, allowing different systems to connect and share data efficiently and securely.

In this topic, will be studied the main characteristics and key points of REST APIs will be studied. We will learn how REST APIs are based on the REST (Representational State Transfer) protocol, allowing for a flexible and lightweight architecture that adapts to a wide range of use cases.

In addition, we will discover the best practices for designing and building robust, secure, and high-performance REST APIs. From creating clear paths and resources to proper error handling and authentication, we’ll explore the most effective techniques for delivering a smooth user experience and seamless interaction between apps and services.

To begin let’s see what the REST APIs are. An “Application Programming Interfaces” (APIs) are a set of rules and protocols that allow different computer systems to communicate and share data over the Internet in a standardized manner. The term “REST” comes from “Representational State Transfer” and is a style of software architecture that is widely used in web application development.

REST APIs are based on the HTTP (Hypertext Transfer Protocol) protocol, which is the protocol used to transmit data on the web. They follow a set of principles and constraints that promote simplicity, scalability, efficiency, and interoperability between systems.

Being related to the HTTP protocol, the actions of the REST APIs are linked to its standard methods, such as GET (to get data), POST (to create new resources), PUT (to update existing resources), and DELETE (to delete resources). ). Each one with the characteristics mentioned above.

REST APIs are widely used in web and mobile application development, as they allow different applications to connect and share data efficiently and securely. By following REST principles, these APIs become easier to understand, use, and maintain, which has led to their popularity in the software development community.

To understand REST APIs, it is important to learn and understand the following key points since each of them is part of the REST APIs.

### **REST**

**“**Representational State Transfer”, commonly known as REST, is a crucial concept to grasp in understanding the fundamentals of REST architecture. It revolves around the appropriate utilization of HTTP methods and the design of web resources.

### **Resource**

The resources are the foundation of REST APIs, representing identifiable and addressable elements or entities on the web. Each resource is uniquely identified by a URL (Uniform Resource Locator), enabling access, creation, updating, or deletion through various HTTP methods (GET, POST, PUT, DELETE, and more).

### **URIs**

The “Uniform Resource Identifiers” (URIs) are used to uniquely identify each resource in the REST API. They are the URLs that allow you to access and manipulate the resources. In addition, URIs help to follow a specific format and represent a hierarchical structure that reflects the organization of resources in the system.

For example,*** [https://example.com/products](https://example.com/products)***

The combination of URIs and HTTP methods allows a RESTful API to offer a uniform and consistent interface for interacting with resources. This makes the API easier to understand and use, as clients only need to know the URIs and methods to interact with different parts of the system.

### **HTTP methods**

The HTTP methods are directly related to REST APIs since HTTP methods are used to perform operations on resources identified by URLs (Uniform Resource Locators).

### **HTTP responses**

Understanding HTTP status codes, which indicate the result of a request, is crucial for developing applications that implement REST APIs.

For example:

* 200 OK — Request Success

* 201 Created — Resource created success

* 204 No Content — Successful request with no content to return

* 400 Bad Request — Incorrect or invalid request

* 401 Unauthorized — Not authorized to access the resource

* 403 Forbidden — Access to the resource is prohibited

* 404 Not Found — Resource not found

* 405 Method Not Allowed — Method not allowed for the resource

* 500 Internal Server Error — Internal server error

* 503 Service Unavailable — Service not available

### **CRUD Operations**

The CRUD is an acronym that stands for the four basic operations on resources: Create, Read, Update, and Delete.

### **JSON**

SON is a lightweight, easy-to-read data exchange format widely used in REST APIs to represent information.

### **Authentication and Authorization**

As an essential part of the security of our REST APIs, it is crucial to understand how access to resources is secured through authentication and authorization, which allows only users and groups of users to access specific resources.

### **API Version**

Adding a version helps ensure compatibility with different versions of the API and prevent disruption for existing customers. Example:

API defined with Version 1: [***https://example.com/v1/products](https://example.com/v1/products)***

API defined with Version 2: [***https://example.com/v2/products](https://example.com/v2/products)***

### **Documentation**

Clear and complete documentation is essential for developers to be able to use a REST API smoothly and take full advantage of its capabilities. We can help each other with tools like OpenAPI.

### **RESTful Design Patterns.**

Get familiar with RESTful design patterns to ensure a consistent and well-structured architecture:

* These patterns are listed as follows:

* Hierarchical URI Pattern

* API Versioning Pattern

* Pagination Pattern

* Filter and Search Pattern

* HATEOAS (Hypermedia as the Engine of Application State) pattern

* Cache Pattern

* Authentication and Authorization Pattern

* Error Handling Pattern

* Push Notification Pattern

* API Gateway Pattern

* Rate Limiting Pattern

* Nested Resource Pattern

* Resource Composition Pattern

## **Best practices to define our APIs**

![img](https://cdn-images-1.medium.com/max/2000/1*-gCptpHpgUbOfo-SgsjBMQ.png)

In the realm of API development, the design of a REST API is crucial to its success and efficiency. Best practices for defining REST APIs provide guidelines and approaches to create robust interfaces that are user-friendly and comprehensible for consumers.

These practices enhance interactions between clients and servers while bolstering scalability, security, and maintainability throughout the API’s lifespan. In this subtopic, we will explore key best practices for effectively designing REST APIs, ensuring seamless integration into diverse applications and services.

Following are listed the main best practices that help to develop good APIs:

### **Always use plural names to identify resources in the URLs**

For example, instead of using “***/product**”*, opt for “***/products***”. This consistent naming convention improves the clarity and intuitiveness of your REST API, making it easier for developers to understand and work with the resources. Additionally, using plural names aligns with standard RESTful practices, promoting consistency and better communication between clients and servers.

### **Using HTTP Methods Semantically**

Ensure the appropriate and consistent use of HTTP methods to reflect CRUD (Create, Read, Update, Delete) operations on resources. For example, use POST to create resources, PUT to update them, and DELETE to delete them. By adhering to these semantic conventions, you enhance the clarity and predictability of your REST API, making it easier for developers to understand and interact with the different resources.

Properly utilizing HTTP methods promotes a standardized and efficient way of communicating with your API, ensuring a smooth and effective experience for clients and servers alike.

### **Maintain Hierarchy in URLs**

Organize URLs in a hierarchical and meaningful manner to represent the relationships between resources effectively.

For example, use a structure like “***/users/{userId}/orders**”* to retrieve the orders associated with a particular user. This practice fosters consistency and clarity in your REST API, leading to improved usability and a smoother development experience, making it easier for developers to navigate and understand the relationships between various resources.

### **Version the API**

By incorporating the version number directly into the URL to ensure future compatibility. For example, utilize “***/v1/products***” to represent version 1 of the Products API.

By versioning the API in this manner, you create a clear distinction between different versions, enabling clients to access the desired version while avoiding potential disruptions in functionality due to changes in future versions. This practice promotes a seamless and robust evolution of your API over time, providing developers with the flexibility to upgrade to newer versions at their own pace while maintaining backward compatibility when necessary.

### **Use Appropriate HTTP Status Codes**

Implementing the appropriate HTTP status codes to accurately indicate the outcome of each request. For example, utilize 200 OK for successful responses and 404 Not Found for resources that cannot be located.

By using HTTP status codes judiciously, you convey crucial information about the state of the request to clients, facilitating proper handling of responses and error scenarios. This practice ensures that clients can effectively interpret and respond to different outcomes during their interactions with the API.

### **Avoid Verbs in URLs**

Avoid incorporating verbs in URLs and stick to using only nouns to represent resources. For instance, prefer “***/products***” over “***/create-product***” when creating a new user.

This principle aligns with the proper implementation of HTTP methods, where the HTTP method itself conveys the action to be performed on the resource. This approach simplifies the URL structure and ensures that the focus remains on the resource itself rather than the action being taken, enhancing the overall readability and usability of your REST API.

### **Allow clients to filter, sort, and paginate results to handle large data sets**

Enable clients to filter, sort, and paginate results to efficiently manage large data sets. By providing these functionalities in your REST API, you empower clients to retrieve only the specific data they require, improving the performance and usability of the API. Filtering allows clients to narrow down results based on specific criteria while sorting enables them to order the data in a preferred manner. Pagination enables clients to retrieve data in smaller, manageable chunks, reducing the load on both the client and the server.

Use query parameters that allow for flexible data filtering.

For example: “***/products?price=30***” or “***/products?active=false***”.

**Protect the API with Authentication and Authorization
**Secure your API by implementing authentication and authorization mechanisms to control resource access.

### **Document the API**

Provide clear and complete documentation of the API, including sample requests and responses, to facilitate its use by developers.

Thoroughly documenting the API is crucial because it provides developers with all the necessary information to use it effectively. Comprehensive documentation explains how to interact with resources, which parameters are required, what responses to expect, and how to handle errors.

Having well-structured and accessible documentation allows developers to quickly grasp the API’s functionality, saving time and reducing the learning curve.

### **Error Handling**

Error handling is a critical aspect of a robust API. When an error occurs, it’s essential to provide clear and detailed error responses to the clients. These error responses should include concise yet highly descriptive error messages, along with the appropriate HTTP status code, which accurately reflects the nature of the error.

By offering comprehensive error information, developers can quickly identify the issue and take appropriate actions to resolve it. Well-designed error handling enhances the overall user experience, as it reduces the frustration caused by vague error messages and assists developers in troubleshooting and debugging their applications effectively.

### **Separate words with hyphens (-)**

Use hyphens to separate words when defining resource names that consist of multiple words. For example, if our resource represents “products best sellers” it is recommended to structure the URL as /products/best-sellers, etc.

This practice, known as “kebab-case,” enhances the readability and clarity of your API URLs which creates a consistent and visually appealing URL structure, promoting better communication between clients and servers and improving the overall user experience.

### **Significant names**

Choose meaningful and descriptive names for your resources and endpoints. This practice greatly enhances the usability of your API for developers, as it ensures that the purpose and functionality of each resource or endpoint are immediately apparent. By using significant names, you create a self-explanatory API that reduces the need for extensive documentation and enables developers to work more efficiently. Well-chosen names also contribute to the maintainability and scalability of the API, as they promote consistency and coherence throughout the design. Ultimately, prioritizing descriptive names simplifies the development process and fosters a seamless experience for those interacting with your API.

### **Avoid too-long names**

Avoid using overly long names for resources and endpoints in your API. Lengthy names can create usability and readability issues, making the API cumbersome to work with and maintain. By keeping names concise and focused, you improve the developer experience and promote a clearer understanding of the API’s structure and functionality.

Additionally, shorter names contribute to cleaner and more organized code, making it easier for developers to manage and update the API in the future. Striking the right balance between descriptive and succinct names ensures an API that is user-friendly, efficient, and sustainable in the long run.

### **Avoid confusing abbreviations**

Avoid abbreviations that may be confusing or unintuitive to developers consuming the API. It is better to opt for clear and descriptive names.

Avoid using confusing or unintuitive abbreviations in your API. Instead, opt for clear and descriptive names that make the API more user-friendly and easier to understand for developers. Ambiguous abbreviations can lead to misunderstandings and errors when consuming the API, while explicit names provide clarity and promote consistency.

### **HATEOAS**

Consider implementing HATEOAS (Hypermedia as the Engine of Application State) in your API design. HATEOAS allows you to include hypermedia links in API responses, enabling clients to dynamically navigate and discover available resources and actions. By providing these links, clients can interact with the API more seamlessly, reducing the need for prior knowledge of resource URIs. This approach promotes a more flexible and self-descriptive API, allowing developers to build more adaptable and resilient applications. Embracing HATEOAS fosters a more discoverable and intuitive API experience, encouraging better client-server interaction and facilitating future API updates and expansions.

Complying with best practices for designing REST APIs is essential to ensure their success and efficiency. Implementing each of these practices is highly recommended to enhance the overall API experience and foster a more productive and collaborative environment between clients and servers.

Furthermore, adhering to these guidelines ensures that our APIs will excel in areas such as ease of use, scalability, security, and maintainability. By following these rules during development, developers can create solid interfaces that seamlessly integrate with various applications and services more easily and reduce issues.

Next readings …

Chapter 6 “HTTP package in golang”.