I built a merge PDF tool that does the opposite: ilovedevtools.com/merge-pdf runs entirely in your browser. Your files never leave your machine. Let me show you how it works and why I think that matters.

What it does

It's the classic merge: you add two or more PDFs, arrange them in the order you want, and get one combined PDF out. Under the hood it uses pdf-lib, a JavaScript library, running locally in your browser tab. There's no backend. Check your browser's network tab while you use it if you don't believe me — nothing goes out.

How to merge two PDFs (invoice + receipt example)

Say you're expensing a purchase and finance wants one file: invoice first, receipt second.

1. Open ilovedevtools.com/merge-pdf.

2. Drag both PDFs onto the drop zone. Only application/pdf files are accepted, so you can't accidentally mix in a stray screenshot.

3. Drag the file previews to reorder them. Files merge left to right in the order shown, so put the invoice first.

4. Hit Merge PDFs. You'll see a summary like "2 files merged into one 4-page PDF" before anything downloads.

5. Confirm and download merged.pdf.

That confirmation step is small but I've grown to like it. You see exactly what you're about to save before it lands in your Downloads folder.

Why client-side matters for this tool

Merging is the tool people reach for with their most sensitive documents. Think about what actually gets merged:

• Contracts and NDAs with terms you're legally bound to.

• Invoices and receipts that contain your name, address, and payment details.

• Application packets — scans of IDs, payslips, bank statements for a rental or visa application.

The last one is the scary one. People routinely email combined ID-and-payslip packets to strangers, and then turn around and upload those same files to a random PDF website with no idea where the servers are or how long files are retained. Some sites delete after an hour. Some say they do, and you have no way to verify it.

With a client-side tool, there's nothing to trust. The file is read into memory with the File API, merged with pdf-lib, and written back out as a Blob your browser downloads. The page doesn't even have a server to send it to. It works offline once the page has loaded, and it works on a plane.

Use cases I actually hit

• Combining scanned pages from a flatbed scanner that saves each page as a separate PDF (why do they all do this?).

• Assembling a job application: cover letter, CV, portfolio excerpt, one file instead of three attachments.

• Monthly bookkeeping: merge that month's receipts into a single PDF named after the month, attach to one email, done.

Honest limitations

• Password-protected PDFs can't be read, so you'll need to unlock or remove the password first (my Unlock PDF tool handles the restriction-only kind — more below).

• Corrupted or oddly-structured PDFs may fail to load; the tool will tell you rather than produce a broken file.

• There's no per-page selection or interleaving. If you need page 3 of file A between pages 1 and 2 of file B, extract those pages first with the Extract PDF Pages tool, then merge.

• Everything runs in your browser's memory, so merging a few hundred megabytes of scans at once depends on your machine. A modern laptop handles a lot, but it's not a server farm.

• Output is always named merged.pdf — rename it yourself after download.

More free browser tools

All of these run 100% client-side too:

• Split PDF — break a merged document back into parts, as a zip.

• Sign PDF — draw or type a signature and place it on any page.

• Unlock PDF — remove restriction-only protection from PDFs that open without a password.

No accounts, no uploads, no watermarks stamped on your output. That's the whole deal.

Generative AI is more than just a buzzword, it's a groundbreaking technology that's reshaping the way we interact with the world. From creating stunning artworks to diagnosing diseases, Generative AI is making waves across multiple domains. In this blog post, we'll explore what Generative AI is and delve into its transformative applications in various industries.

What is Generative AI?

Generative AI refers to a subset of artificial intelligence that focuses on creating new content. Unlike traditional AI, which is designed to recognise patterns and make decisions based on existing data, Generative AI can produce new data that mimics the characteristics of the original dataset.

It can create new, original content, such as text, images, music, or videos, based on patterns and structures learned from existing data. These systems use algorithms to generate novel outputs that are often indistinguishable from those created by humans, making them useful for applications like art, entertainment, and even scientific discovery.This is achieved through advanced algorithms like Generative Adversarial Networks (GANs) and Variational Auto encoders (VAEs).

Generative AI works by training two neural networks: a generator and a discriminator. The generator creates new data, while the discriminator evaluates it against real data. Through this adversarial process, the generator improves its ability to produce realistic data over time. This technology has opened up new possibilities in various fields, from generating realistic images and videos to creating synthetic data for research and development.

Large Language Models (LLMs)

Large Language Models (LLMs) are a specific type of Generative AI designed to understand and generate human-like text. These models, such as OpenAI's GPT-4, are trained on vast amounts of text data and can perform a wide range of language-related tasks, including

• Text translation

• Text summarisation

• Content creation

• Text Categorisation

• Image/Video Content Extraction

LLMs have revolutionised natural language processing (NLP) and are being used in numerous applications across different industries.

Applications of Generative AI in Various Domains

Healthcare

Generative AI is revolutionising healthcare by enabling the creation of synthetic medical data, which can be used for research and training without compromising patient privacy. It also aids in drug discovery by simulating molecular structures and predicting their interactions.

Example 1: Researchers at Insilico Medicine used Generative AI to identify potential new drugs for fibrosis, significantly speeding up the drug discovery process.

Example 2: IBM Watson Health employs Generative AI to create synthetic patient data for training machine learning models, enhancing the accuracy of diagnostic tools.

Finance

In the financial sector, Generative AI is used to detect fraudulent activities by generating synthetic transaction data to train more robust fraud detection systems. It also helps in algorithmic trading by simulating market conditions and testing trading strategies.

Example 1: JPMorgan uses Generative AI to create synthetic data for stress testing financial models, ensuring they can withstand various economic scenarios.

Example 2: Mastercard uses Generative AI to generate synthetic transaction data, improving the accuracy of their fraud detection algorithms.

Art and Entertainment

Generative AI is making a significant impact in the creative industries by generating music, art, and even scripts. Artists and creators use these tools to push the boundaries of their creativity and produce unique works.

Example 1: The AI-generated painting "Portrait of Edmond de Belamy" was auctioned at Christie's for $432,500, showcasing the potential of AI in the art world.

Example 2: OpenAI's MuseNet can compose original music in various styles, from classical to contemporary, demonstrating the creative potential of Generative AI in music.

Marketing and Advertising

In marketing, Generative AI is used to create personalised content and advertisements. By analysing consumer data, AI can generate tailored marketing messages that resonate with individual preferences, leading to higher engagement rates.

Example 1: Coca-Cola used Generative AI to create personalised video ads for its "Share a Coke" campaign, resulting in a significant increase in customer engagement.

Example 2: The North Face leverages Generative AI to create personalised product recommendations and marketing content, enhancing the customer shopping experience.

Education

Generative AI is transforming education by creating personalized learning experiences. It can generate customized educational content, quizzes, and even tutor students based on their learning pace and style.

Example 1: Duolingo uses Generative AI to create personalized language exercises, helping users learn more effectively.

Example 2: Squirrel AI, an adaptive learning platform, employs Generative AI to tailor educational content to individual student needs, improving learning outcomes.

Information Technology

In the tech industry, Generative AI is used to automate code generation, enhance cybersecurity, and create realistic simulations for training and development.

Example 1: GitHub Copilot, powered by OpenAI's Codex, assists developers by generating code snippets and suggesting improvements, streamlining the coding process.

Example 2: NVIDIA uses Generative AI to create realistic virtual environments for training autonomous vehicles, improving the safety and efficiency of self-driving technology.

Conclusion

Generative AI is a powerful tool that's transforming various industries by enabling the creation of new, innovative solutions. From healthcare to entertainment, its applications are vast and varied, offering endless possibilities for the future. As we continue to explore and develop this technology, the potential for Generative AI to revolutionise our world is truly limitless.

Kubernetes is the go-to orchestration system for managing containerized applications across multiple hosts. It provides tools to deploy applications, scale them as needed, manage changes to existing containerized applications, and helps optimize the use of underlying hardware beneath your containers. Minikube is a tool that makes it easy to run Kubernetes locally. In this blog post, we'll walk through deploying a simple "Hello World" application using Nginx on Kubernetes with Minikube.

Prerequisites

Before starting, ensure you have the following installed:

• Docker, for creating container images and running containers.

• Minikube, for a local Kubernetes cluster.

• kubectl, the command-line tool for interacting with Kubernetes.

Step 1: Setting Up Minikube

Minikube simplifies the initial setup of a Kubernetes cluster:

minikube start

Verify that Minikube is properly set up by running:

minikube status

Step 2: Creating Your Nginx Container

Create a Dockerfile for your Nginx "Hello World" application.

FROM nginx:alpine
COPY ./index.html /usr/share/nginx/html/index.html

Here's a simple index.html to serve:

<!DOCTYPE html>
<html>
<head>
<title>Hello World</title>
</head>
<body>
<h1>Hello World from Nginx!</h1>
</body>
</html>

Build and tag the Docker image, then push it to your Docker registry

docker build -t hello-nginx:latest .

Note: If using Minikube's Docker daemon, you don't need to push the image to a registry.

Step 3: Writing the Kubernetes Deployment File

Create a deployment.yaml file that tells Kubernetes how to create and manage your application's instances.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-nginx
spec:
  replicas: 2
  selector:
    matchLabels:
      run: hello-nginx
  template:
    metadata:
      labels:
        run: hello-nginx
    spec:
      containers:
      - name: hello-nginx
        image: hello-nginx:latest
        ports:
        - containerPort: 80

Deploy your application to Kubernetes using kubectl.

kubectl apply -f deployment.yaml

Step 4: Accessing Your Application

To make your application accessible, expose it via a service.

kubectl expose deployment hello-nginx --type=NodePort --port=80

Retrieve the URL to access your Nginx application:

minikube service hello-nginx --url

Step 5: Scaling Your Deployment

You can easily scale the number of replicas in your deployment:

kubectl scale deployment hello-nginx --replicas=3

Check the status of your scaled deployment:

kubectl get deployment hello-nginx

Step 6: Cleaning Up

Once you are done, you can delete the service and deployment:

kubectl delete service hello-nginx

And stop Minikube with:

minikube stop

Conclusion

This guide provided a straightforward walkthrough for setting up a Kubernetes cluster with Minikube, deploying a simple "Hello World" Nginx application, and scaling it. Kubernetes’ ability to handle this deployment process showcases the power and flexibility of the platform. Whether you're a developer new to containerization or an operations engineer looking to automate your deployments, Kubernetes and Minikube together offer a robust toolset for managing containerized applications.

Local Development vs. Production Environments

It's important to note that Minikube is intended for local development, learning, and testing purposes. Its ease of setup and use provides a great sandbox for individuals to experiment with Kubernetes and understand its features without the overhead of a full-scale deployment.

For production environments, where reliability, scalability, and security are paramount, enterprise-grade solutions are recommended. Services like AWS Elastic Kubernetes Service (EKS), Google Kubernetes Engine (GKE), or Azure Kubernetes Service (AKS) offer managed Kubernetes experiences which handle much of the complexity and operational overhead. These services provide robust, scalable, and secure infrastructure to run your containerized applications in the cloud.

By starting with Minikube, you build a solid foundation that will aid in understanding how Kubernetes operates at a larger scale in a cloud environment. As you transition from a local to a production environment, you'll be able to appreciate the full potential of Kubernetes and how it can be leveraged to meet the demands of your applications and services.

Remember, the journey into Kubernetes is as rewarding as it is challenging. The skills you develop while managing and scaling your applications will be invaluable as you move towards cloud-native development and operations

‍Kubernetes is an open-source orchestration software for deploying, managing, and scaling containers. Modern applications are increasingly built using containers, which are microservices packaged with their dependencies and configurations. Kubernetes (pronounced "koo-ber-net-ees") is open-source software for deploying and managing those containers at scale and it’s also the Greek word for helmsmen of a ship or pilot. Build, deliver, and scale containerized apps faster with Kubernetes sometimes referred to as "k8s" or "k-eights".

What is container orchestration?

Container orchestration is the automation of much of the operational effort required to run containerized workloads and services. This includes a wide range of things software teams need to manage a container’s lifecycle, including provisioning, deployment, scaling (up and down), networking, load balancing, and more.

While containers are a very effective way of running your applications, there is one major challenge associated with them which is container orchestration. They need a solution to run in a production environment. The idea is to continuously monitor and manage these containers to ensure continuity of services. Some of the checks involved with this management include ensuring that the system is fine and is not experiencing any downtime. This process of running and scaling containers in the production environment becomes quite a tricky option.

Kubernetes was introduced as a solution to this particular complex problem. It helps you manage the distributed container system effectively, running and scaling the containers while taking care of downtime easily. It provides advantages based on load balancing, storage orchestration, configuration management, automated rollouts, etc...

In this article, we will discuss the core functionality of Kubernetes and how effectively it can be used as a service for orchestrating and managing many containers.

Why do you need to understand Kubernetes?

Kubernetes or K8S provides several key features that allow us to run immutable infrastructure. Containers can be killed, replaced, and self-heal automatically, and the new container gets access to those support volumes, secrets, configurations, etc., that make it function.

The following features of K8S help to manage containers and also make your containerized application scale efficiently:

• Service discovery and load balancing - Containers get their own IP so you can put a set of containers behind a single DNS name for load balancing.

• Storage orchestration - Automatically mount local or public cloud or network storage.

• Secret and configuration management - Create and update secrets and configs without rebuilding your image.

• Self-healing - The platform heals many problems like restarting failed containers, replacing and rescheduling containers as nodes die, killing containers that don’t respond to your user-defined health check, and waiting to advertise containers to clients until they’re ready.

• Batch execution - Manage your batch and Continuous Integration workloads and replace failed containers.

• Automatic bin packing - Automatically schedules containers based on resource requirements and other constraints.

• Automated rollouts and rollbacks - Roll out changes that monitor the health of your application thereby ensuring all instances don't go down simultaneously. If something goes wrong, K8S automatically rolls back the change.

• Horizontal scaling - Scale your application by launching more instances of your application as needed from the command line or UI.

Kubernetes Core Components

Kubernetes gives you the platform to schedule and run containers on clusters of physical or virtual machines. Kubernetes architecture divides a cluster into components that work together to maintain the cluster's defined state.

Clusters

A Kubernetes cluster is a set of node machines for running containerized applications. You can visualize a Kubernetes cluster as two parts:

1. The control plane

2. The compute machines or nodes.

Each node is its own Linux environment and could be either a physical or virtual machine. Each node runs pods, which are made up of containers.

Control Plane

The control plane's components make global decisions about the cluster (for example, scheduling), as well as detecting and responding to cluster events (for example, starting up a new pod when a deployment's replicas field is unsatisfied). Below are the components of the Control Plane.

API Server

The API server is a component of the Kubernetes control plane that exposes the Kubernetes API. The API server is the front end for the Kubernetes control plane.

The main implementation of a Kubernetes API server is kube-apiserver. kube-apiserver is designed to scale horizontally-that is, it scales by deploying more instances. You can run several instances of kube-apiserver and balance traffic between those instances.

Etcd

etcd is the consistent and highly available key-value store used as Kubernetes backing store for all cluster data. If your Kubernetes cluster uses etcd as its backing store, make sure you have a backup plan for those data.

You can find in-depth information about etcd in the official documentation.

Kube Controller Manager

This Control plane component runs the controller processes. Logically, each controller is a separate process, but to reduce complexity, they are all compiled into a single binary and run in a single process. Some types of these controllers are:

• Node controller - Responsible for noticing and responding when nodes go down.

• Job controller - Watches for Job objects that represent one-off tasks, then creates Pods to run those tasks to completion.

• Endpoints controller - Populates the Endpoints object (that is, joins Services & Pods).

• Service Account & Token controllers - Create default accounts and API access tokens for new namespaces.

Cloud Controller Manager

This control plane component embeds cloud-specific control logic. The cloud controller manager lets you link your cluster into your cloud provider's API, and separates out the components that interact with that cloud platform from components that only interact with your cluster.

The cloud-controller-manager only runs controllers that are specific to your cloud provider. If you are running Kubernetes on your own premises, or in a learning environment inside your own PC, the cluster does not have a cloud controller manager. The following controllers can have cloud provider dependencies:

• Node controller - This is used for checking the cloud provider to determine if a node has been deleted in the cloud after it stops responding

• Route controller - This is used for setting up routes in the underlying cloud infrastructure

• Service controller - This is used for creating, updating, and deleting cloud provider load balancers

Nodes

Node components run on every node, maintaining running pods and providing the Kubernetes runtime environment

kubelet

An agent that runs on each node in the cluster. It makes sure that containers are running in a Pod. It ensures that the containers described are running and healthy.

kube-proxy

It maintains network rules on nodes. These network rules allow network communication to your Pods from network sessions inside or outside of your cluster.

Deploying an Application

A Kubernetes deployment is a resource object in Kubernetes that provides declarative updates to applications. A deployment allows you to describe an application’s life cycle, such as which images to use for the app, the number of pods there should be, and the way in which they should be updated.

The process of manually updating containerized applications can be time-consuming and tedious. A Kubernetes deployment makes this process automated and repeatable. Deployments are entirely managed by the Kubernetes backend, and the whole update process is performed on the server-side without client interaction.

The Kubernetes deployment object lets you:

• Deploy a replica set or pod

• Update pods and replica sets

• Rollback to previous deployment versions

• Scale a deployment

• Pause or continue a deployment

Access Control

Users access the Kubernetes API using kubectl, client libraries, or by making REST requests. Both human users and Kubernetes service accounts can be authorized for API access. When a request reaches the API, it goes through the following stages

Authentication

The input to the authentication step is the entire HTTP request; however, it typically examines the headers and/or client certificates. Authentication modules include client certificates, passwords, and plain tokens, bootstrap tokens, and JSON Web Tokens. Multiple authentication modules can be specified, in which case each one is tried in sequence until one of them succeeds.

If the request cannot be authenticated, it is rejected with HTTP status code 401. Otherwise, the user is authenticated as a specific username for further stages.

Authorization

A request must include the username of the requester, the requested action, and the object affected by the action. The request is authorized if an existing policy declares that the user has permission to complete the requested action.

Example :

• If Bob makes a request to write (create or update) to the objects in the development namespace, his authorization is denied if his role is not allowed in the update/create policy.

• If Bob makes a request to read (get) objects in a different namespace such as production, then his authorization is denied.

Kubernetes supports multiple authorization modules, such as ABAC mode, RBAC (Role-Based Access Control) Mode, and Webhook mode. If all of the modules deny the request, then the request is denied (HTTP status code 403).

Admission control

Admission Control modules are software modules that can modify or reject requests. In addition to the attributes available to Authorization modules, Admission Control modules can access the contents of the object that is being created or modified. Unlike Authentication and Authorization modules, if any admission controller module rejects, then the request is immediately rejected.

Secret Management

Kubernetes Secrets are secure objects which store sensitive data, such as passwords, OAuth tokens, and SSH keys, etc. with encryption in your clusters. Using Secrets gives you more flexibility in a Pod Life cycle definition and control over how sensitive data is used. It reduces the risk of exposing the data to unauthorized users.

Kubernetes etcd is the consistent and highly available key-value store used for storing Kubernetes secrets. Below are few characteristics of Kubernetes Secret

• Secrets are namespaced objects.

• Secrets can be mounted as data volumes or environment variables to be used by a container in a pod.

• Secret data is stored in tmpfs in nodes

• API server stores secrets as plain text in etcd

• A per-secret size limit of 1MB

Scheduler

kube-scheduler is the control plane component that watches for newly created Pods with no assigned node, and selects a node for them to run on. The Scheduler is responsible for the scheduling of containers across the nodes in the cluster.

Factors taken into account for scheduling decisions include

• Individual and collective resource requirements

• Hardware/Software/policy constraints like CPU, Memory, etc...

• Data locality

• Inter-workload interference

Minikube

Minikube is a tool that lets you run Kubernetes locally. minikube runs a single-node Kubernetes cluster on your personal computer (including Windows, macOS, and Linux PCs) so that you can try out Kubernetes, or for daily development work.

You can follow the official Get Started! guide if you want to install this tool. Once minikube is installed you are now ready to run a virtualized single-node cluster on your local machine.

You can start your minikube cluster with

minikube start

Interacting with Kubernetes clusters is mostly done via the kubectl CLI. You can install the kubectl CLI on your machine by using the official installation instructions.

Conclusion

Even though containers are a very effective way of running your applications, container orchestration is the major challenge associated with them. Kubernetes exactly addresses this challenge and simplifies the container orchestration with features like Service discovery and load balancing, Horizontal scaling, Ease of deployment, Configuration and secrets management, Scheduler, Network rules management, providing access control based on different environments, users, and roles.

Companies across the world are now putting in a lot of effort to run their apps on the Kubernetes platform. One of the primary reasons for this is that with this platform, you can reduce the time it takes to deploy on the market. This can be attributed to more efficient app development efficiencies. In effect, it also paves the way for IT cost optimization. Another important reason why companies are putting in an effort to run their application on Kubernetes is its improved scalability as it is known for automatically scaling and improving app performances.

Geospatial data, or data that represents a location on the Earth's surface, is becoming increasingly prevalent in today's data-driven world. To effectively work with geospatial data, databases need to have the ability to perform geospatial queries, which allow users to search, filter and analyze this data based on location. In this blog post, we will focus on implementing geospatial queries in MySQL, one of the most popular open-source relational databases.

1.Enabling Geospatial Support in MySQL

MySQL does not have built-in geospatial support, but it can be enabled through the installation of a plugin called "MySQL Spatial Extensions." This plugin adds a set of geospatial data types and functions that allow for the creation and querying of geospatial data. To install the plugin, you can run the following command:

INSTALL PLUGIN mysql_no_login SONAME 'libgeometry.so';

2.Creating a Geospatial Table in MySQL

To create a geospatial table in MySQL, you will need to specify the geospatial data type for each column that will contain geospatial data. Some common geospatial data types in MySQL include POINT, LINESTRING, and POLYGON.

Here is an example of how you can create a table to store restaurant locations:

CREATE TABLE restaurants (
  id INT PRIMARY KEY AUTO_INCREMENT,
  name VARCHAR(255),
  location POINT
);

3.Indexing Geospatial Data in MySQL

To improve query performance, it is recommended to create a spatial index on the geospatial column. This can be done by using the following syntax:

ALTER TABLE restaurants ADD SPATIAL INDEX (location);

4.Performing Geospatial Queries in MySQL

Once the geospatial data has been indexed, it can be queried using geospatial functions. Some common geospatial functions in MySQL include ST_Distance, ST_Within, and ST_Contains.

Here is an example of how you can find all restaurants within a certain radius of a location:

SELECT * FROM restaurants WHERE ST_DWithin(location, POINT(longitude, latitude), radius);

5.Other Databases Supporting Geospatial Queries

MySQL is not the only database that supports geospatial queries. Other popular databases that support geospatial queries include:

• PostgreSQL with PostGIS extension

• Microsoft SQL Server with spatial data types and functions

• Oracle with Spatial and Graph option

• MongoDB with native support for geospatial data and indexing

Conclusion

Geospatial queries allow databases to effectively work with geospatial data, enabling users to perform location-based analysis and search operations. Implementing geospatial queries in MySQL requires enabling geospatial support through the installation of a plugin and creating a geospatial table with the proper data types and indexes. Whether you are working with real estate data, tracking delivery trucks, or mapping out locations, geospatial queries provide a powerful tool for analyzing and understanding location-based data.

Database indexing is a fundamental concept for optimizing the performance of database queries. It enables faster data retrieval by providing a quick way to look up specific rows of data in a table. In this blog post, we will take a deep dive into the world of database indexing, including the different types of indexes, the benefits of indexing, and best practices for indexing your database.

What is an Index?

An index is a data structure that improves the performance of database queries by providing quick access to specific rows of data in a table. It works by creating a copy of the data in a specific order, making it easy to find specific rows of data. Indexes can be thought of as an extra layer of organization on top of the data stored in a table.

Why Use Indexes?

Without an index, a database must scan the entire table to find the specific rows of data requested in a query. This can be slow when the table has a large number of rows. Indexes improve the performance of queries by allowing the database to quickly find the specific rows of data requested in a query without having to scan the entire table. This can lead to significant performance improvements, especially for large tables or tables with a large number of rows.

Types of Indexes

Several types of indexes can be used in a database. The most common types of indexes are:

• B-tree index: This is the most common type of index and is used in most relational databases. B-tree indexes are efficient for both small and large tables and are well-suited for equality and range queries.

• Hash index: This type of index is used primarily for equality queries on a small number of columns. Hash indexes are faster than B-tree indexes for equality queries but are not efficient for range queries.

• Bitmap index: This type of index is used to efficiently find specific rows of data in a table with a large number of columns. Bitmap indexes are efficient for both equality and range queries but are not well-suited for large tables.

• Clustered index: This type of index determines the physical order of the data in a table. Each table can have only one clustered index.

Creating Indexes

To create an index in a database, you must specify the name of the index, the name of the table that the index will be created on, and the columns that will be included in the index. The syntax for creating an index will vary depending on the type of database you are using. Here is an example of how to create an index in a MySQL database:

CREATE INDEX index_name ON table_name (column1, column2);

It is important to note that indexing can also hurt performance if done excessively or inappropriately, so it's crucial to carefully select the columns that need to be indexed and avoid indexing columns that are rarely used in queries.

Maintenance

Indexes require maintenance to keep them up-to-date and efficient. When a table is modified (rows are inserted, updated, or deleted), the corresponding index must be updated as well. This is known as index maintenance. If the index is not maintained properly, it can lead to poor performance.

Conclusion

In this blog post, we've discussed the basics of database indexing and why it's an important aspect of database management. We've also shown how to implement an index and the importance of proper index selection. By understanding and implementing proper indexing, you can greatly improve the performance of your database queries and ensure efficient data retrieval.

One of the most important concepts in Linux is file permissions. It's what allows you to control who can read, write, and execute files and directories on your system. The chmod (change mode) command is used to change the permissions of files and directories in Linux. It's a powerful command, and mastering it can be a bit tricky, especially for new Linux users. In this post, we'll go over a chmod command cheatsheet with examples to help you understand and use file permissions in Linux.

What is chmod?

The chmod command is used to change the permissions of files and directories in Linux. It allows you to specify which users and groups can read, write, and execute a file or directory. The chmod command works by changing the mode of a file or directory. The mode is a set of three octal (numeric) digits that specify the permissions for the file's owner, group, and others.

Permission Types:

• r: read

• w: write

• x: execute

Permission Classes:

• u: user (owner)

• g: group

• o: other

• a: all (user, group, and other)

Syntax:

The basic syntax for chmod is:

chmod [permission] [file or directory]

Numeric Notation:

• The first digit represents the owner's permissions

• The second digit represents the group's permissions

• The third digit represents the permissions for others

• Each digit can have a value between 0 and 7

Examples:

chmod 755 file.txt  # grants owner read, write and execute permissions and read, execute permissions for group and other
chmod 744 file.txt  # grants owner read, write permissions and read permissions for group and other
chmod 700 file.txt  # grants owner read, write and execute permissions, no permissions for group and other

Symbolic Notation:

• "+" adds a permission

• "-" removes a permission

• "=" sets the exact permissions

Examples:

chmod u+rwx file.txt # grants owner read, write, and execute permissions
chmod g+rw file.txt # grants group read and write permissions
chmod o-r file.txt  # removes read permissions for others
chmod a=rw file.txt # sets read and write permissions for owner, group and others

Conclusion:

In this post, we've covered the basics of the chmod command, including its syntax, numeric notation, and symbolic notation. We've also provided examples of how to use the command to change file permissions in Linux. Remember that changing the permissions of important system files can cause issues with your system, so it's always recommended to back up any important files before modifying their permissions. With this cheat sheet, you should have a better understanding of how to use the chmod command to manage file permissions in Linux.

When choosing a database management system, two of the most popular options are MongoDB and MySQL. Both are widely used and have their own strengths and weaknesses. In this post, we'll explore the differences between MongoDB and MySQL and help you determine which one is the best fit for your needs.

1. Data Modeling

One of the main differences between MongoDB and MySQL is the way they handle data modeling. MongoDB is a document-oriented database management system, which means that it stores data in a semi-structured format, similar to JSON.

On the other hand, MySQL is a relational database management system, which means that it stores data in a structured format using tables, rows, and columns.

2. Scalability

Another important difference between MongoDB and MySQL is scalability. MongoDB is designed to scale horizontally, which means that it can easily handle a large amount of data by adding more servers to the database.

MySQL can also scale horizontally, but it may require more complex configuration and management. MongoDB also supports sharding, which allows you to split large collections of data across multiple servers.

3. Performance

When it comes to performance, both MongoDB and MySQL have their own strengths. MongoDB is known for its high performance when it comes to read and write operations on large datasets. This is because it stores data in a single document, which allows for faster querying and indexing.

MySQL, on the other hand, is known for its high performance when it comes to complex queries and joins. This is because it stores data in multiple tables, which allows for more efficient querying and indexing of structured data.

4. Indexing

MongoDB supports indexing on any field in a document, and it also supports full-text search. MySQL supports indexing on any column in a table, and it also supports full-text search. However, MongoDB's indexing is more flexible, as it allows for indexing on any field, whereas MySQL's indexing is more structured, as it only allows for indexing on specific columns.

5. ACID Compliance

MySQL is fully ACID (Atomicity, Consistency, Isolation, Durability) compliant, which means that it guarantees that database transactions will be atomic, consistent, isolated, and durable. MongoDB, on the other hand, is not fully ACID compliant, but it does support atomic transactions at the document level.

6. Data Types

MySQL supports a wide range of data types, such as integers, strings, and dates, whereas MongoDB only supports a limited set of data types, such as strings and numbers.

7. Replication

Both MongoDB and MySQL support replication, which allows you to create multiple copies of your data for redundancy and high availability. However, MongoDB's replication is more flexible, as it allows you to create a replica set, which is a group of servers that maintain copies of the same data.

MySQL's replication is more structured, as it only allows you to create a master-slave setup, where one server acts as the master and one or more servers act as slaves.

8. Sharding

MongoDB supports sharding, which allows for horizontal scaling by splitting large collections of data across multiple servers. MySQL does not support sharding.

9. Auto-Sharding

MongoDB supports auto-sharding, which automatically distributes data across multiple servers. MySQL does not support auto-sharding.

10. Geospatial Indexing

MongoDB supports geospatial indexing, which allows for efficient querying of data based on geographic location. MySQL does not support geospatial indexing.

Conclusion:

MongoDB and MySQL are both powerful and popular database management systems, but they have their own strengths and weaknesses. MongoDB excels in flexible data modeling, scalability, and read and write operations on large datasets. MySQL is better for complex queries and joins, and is fully ACID compliant. By understanding the differences between MongoDB and MySQL, you can choose the right database management system for your needs and optimize your development process.

A code editor is a must-have tool for any developer, and there are many open-source options available. These editors can enhance your productivity by providing features such as syntax highlighting, code completion, and debugging tools. In this post, we'll explore the top 5 open-source code editors that can help you improve your productivity as a developer.

1. Visual Studio Code

Visual Studio Code (VSCode) is a popular open-source code editor that is highly customizable and extendable. It has a wide range of features including syntax highlighting, code completion, and debugging tools. VSCode also has a large collection of extensions available that can add additional functionality, such as support for specific programming languages or debugging tools.

2. Sublime Text

Sublime Text is a powerful and lightweight code editor that is known for its speed and ease of use. It has a minimalist user interface and offers features such as syntax highlighting, code completion, and multiple selections. Sublime Text also has a large collection of plugins and packages available that can add additional functionality.

3. Atom

Atom is a modern and open-source code editor that is highly customizable and extendable. It has a sleek and intuitive user interface, and it offers features such as syntax highlighting, code completion, and built-in package manager. Atom also has a large collection of packages available that can add additional functionality, such as support for specific programming languages or debugging tools.

4. Notepad++

Notepad++ is a popular open-source code editor that is known for its speed and efficiency. It has a minimalist user interface and offers features such as syntax highlighting, code completion, and built-in support for multiple languages. Notepad++ also has a large collection of plugins available that can add additional functionality.

5. GNU Emacs

GNU Emacs is a highly extensible and customizable code editor that has been around for decades. It offers features such as syntax highlighting, code completion, and built-in support for multiple languages. GNU Emacs also has a large collection of packages available that can add additional functionality, such as support for specific programming languages or debugging tools.

Conclusion:

Choosing the right code editor can greatly enhance your productivity as a developer. Visual Studio Code, Sublime Text, Atom, Notepad++ and GNU Emacs are some of the top open-source code editors that can help you work more efficiently and effectively. By mastering these editors, you can streamline your development process and deliver high-quality software on time.

Git is a powerful version control system that allows developers to track and manage changes to their code. One of the most useful Git commands is git show, which allows you to view the details of a specific commit. In this post, we'll explore the git show command and provide a cheat sheet of some of the most commonly used options.

1. Basic Usage

The basic usage of the git show command is to display the details of a specific commit. You can use the following syntax to view the details of a commit:

git show <commit-hash>

This command will display the commit message, the author, the date, and the changes made in the commit.

2. Showing Changes

One of the most useful options of the git show command is the ability to view the changes made in a specific commit. You can use the following syntax to view the changes made in a commit:

git show <commit-hash> --stat

This command will display a summary of the changes made in the commit, including the number of files changed and the number of lines added or removed.

3. Showing Diffs

Another useful option of the git show command is the ability to view the actual diffs (differences) made in a specific commit. You can use the following syntax to view the diffs made in a commit:

git show <commit-hash> --patch

This command will display the actual diffs made in the commit, including the lines added and removed.

4. Showing File Changes

You can also use the git show command to view the changes made to a specific file in a specific commit. You can use the following syntax to view the changes made to a file:

git show <commit-hash> <file-path>

This command will display the changes made to the specified file in the specified commit.

5. Showing Branch

you can also use git show command to see the latest commit on a branch, you can use the following syntax

git show <branch-name>

Conclusion:

The git show command is a powerful Git command that allows you to view the details of a specific commit. It's a useful tool for understanding the changes made to your code and for debugging. The basic usage, showing changes, showing diffs, showing file changes, and showing branch are some of the most commonly used options of the git show command. By mastering these options, you can quickly and easily view the details of specific commits in your Git repository.

1. Identifying the Requirements

The first step in designing a system is to identify the requirements. This includes understanding the problem that the system is trying to solve, the users that will be interacting with the system, and the constraints that the system must operate within. It's essential to have a clear understanding of the problem to ensure that the system is designed to address it effectively.

2. Scalability

Scalability is one of the most important considerations in system design. A system that can handle an increasing number of users and transactions without significant performance degradation is considered scalable. It's essential to design systems that can handle an increasing load without requiring significant changes to the underlying architecture.

3. High availability

High availability refers to the ability of a system to provide uninterrupted service to its users even in the event of failures. This is especially important in systems that need to be available 24/7, such as online retailers or financial systems. To achieve high availability, it's essential to design systems that can handle failures at different levels, such as hardware failures, network failures, and software bugs.

4. Performance

Performance is another critical consideration in system design. A system that can handle a high number of transactions or requests per second is considered to have good performance. It's essential to design systems that can handle the expected load in a timely manner to ensure a good user experience.

5. Security

Security is an essential aspect of system design. Systems must be designed to protect against unauthorized access and data breaches. This includes implementing secure communication protocols, access controls, and encryption. It's essential to design systems that can prevent unauthorized access and protect sensitive data.

Conclusion:

System design is a complex process that involves understanding the problem that the system is trying to solve, the users that will be interacting with the system, and the constraints that the system must operate within. Scalability, high availability, performance, and security are some of the key considerations to keep in mind when designing a system. By keeping these principles in mind, you can create scalable, maintainable, and efficient systems that provide a good user experience.

1. Flexible Schema
2. Fast & Flexible Querying
3. Horizontal Scalability
4. Ease of use

What is a Document Database?

There are four types of NoSQL databases like Document Databases, Wide-column databases, Key-Value databases & Graph databases.

Document Databases store data in a similar structure as JSON objects. Each document is equivalent to a database row in a traditional SQL database.

Each document contains keys and values. Value can be of any type ranging from string, number, boolean, array, or another nested object. In this article, I will list 4 popular NoSQL document databases which can be used to evaluate for your next application.

• MongoDB
• Amazon DynamoDB
• CouchDB
• Couchbase

MongoDB

MongoDB is one of the most popular NoSQL document databases which stores data in the form of collections and documents, instead of using tables and rows as in relational databases. It is completely implemented in C++ and developed by MongoDB, Inc in 2009. It has Open Source License.

Below are some of the key features of MongoDB

• Document Oriented - collections are equivalent to tables in a relational database. Each collection has a set of documents equivalent to a record in a relational database.
• Schemaless Database - Documents do not need to have a schema defined beforehand and fields can be created instantly.
• Indexing - It supports primary and secondary indices on document fields which makes it easier to search and takes less time to fetch the data
• Replication - It supports master/slave replication as well as Cluster mode replication.
• Sharding - Supports data sharding
• Load Balancing - Supports automatic load balancing based on the data stored in shards
• Aggregation and Map reduce tools - Supports operations to query the grouped data and fetch the computed result.
• Spatial DBMS - It has support for geo-spatial queries like radius search, bounding box search, etc...
• Backup & restore support
• Security - Supports Role-Based Authorization

Amazon DynamoDB

Amazon DynamoDB is a NoSQL database that supports both Document oriented and Key Value data models. It is developed by Amazon in 2012 and has a commercial license.

Below are some of the key features of DynamoDB

• Document Oriented
• Supports Key-Value storage
• Schemaless Database
• Sharding - Supports sharding via partitions
• Indexing - It supports primary and secondary indices on document fields
• AWS ecosystem Support - Good Integration support with other AWS components like Lambda, AWS streams, Redshift, etc...
• Backup & restore support
• Security - Supports Role-Based Authorization

CouchDB

CouchDB is a NoSQL Document data store developed by Apache Software Foundation in 2005 and has Open Source License.

Each document that is stored in the database is given a document-level unique identifier _id as well as a revision _rev number for each change that is made and saved to the database.

Below are some of the key features of CouchDB

• Document Oriented
• Schemaless Database
• Sharding
• Indexing - It supports primary and secondary indices on document fields
• Aggregation and Map reduce tools - Supports operations to query the grouped data and fetch the computed result.
• Spatial DBMS - It has support for geo-spatial queries like radius search, bounding box search, etc...
• Browser-Based GUI - It has GUI called Futon which enables a browser-based GUI to handle your data, permission, and configurations.
• Backup & restore support
• Security - Supports Role-Based Authorization

Couchbase

Couchbase is a NoSQL database that supports both Document oriented and Key Value data models. It is developed by Couchbase, Inc in 2011 and has Open Source License.

The data is stored in a Couchbase cluster using buckets. Buckets are isolated group records within a cluster. A bucket is the equivalent of a database. They provide a secure mechanism for organizing, managing, and analyzing data storage.

Documents are distributed uniformly across the cluster and stored in the buckets.

Couchbase has a built-in managed cache to enable a memory-first architecture. Read and write operations run at the speed of RAM.

Below are some of the key features of Couchbase

• Document Oriented
• Schemaless Database
• Sharding
• Replication
• Indexing - It supports primary and secondary indices on document fields
• Spatial DBMS - It has support for geo-spatial queries like radius search, bounding box search, etc...
• Automatic Failover support in case any of the nodes in the cluster goes down
• Backup & restore support
• Security - Supports Role-Based Authorization

Thank you for reading

Hope you find these resources useful. If you like what you read and want to see more about system design, microservices, and other technology-related stuff... You can follow me on

• Twitter - Follow @vishnuchi

For this tutorial, I will be using

• Ruby 2.6.3
• Rails 5.2.6
• Bootstrap 5
• SQLite Database

But this step-by-step tutorial should work for the latest Ruby & Rails versions as well.

Index

• Create a project
• Start server
• Create Model, Controller and Views
• Database Migration
• Change Application Root
• Integrate Bootstrap
• Add Navigation Bar
• Add Movie status Select option
• Styling Course Forms

Create a project

• Let's name our project as binged - The Binge-Watch Tracker

rails new binged

This command will create a project binged with the following structure.

cd binged/

.
├── Gemfile
├── Gemfile.lock
├── README.md
├── Rakefile
├── app
├── bin
├── config
├── config.ru
├── db
├── lib
├── log
├── package.json
├── public
├── storage
├── test
├── tmp
└── vendor

11 directories, 6 files

Start server

• Run rails server or rails s (shortcut) to start the server and visit http://localhost:3000 in your browser. If there are no errors you will see the following screen.

Create Model, Controller, and Views

Let's create a Movie Model and corresponding Controller using rails scaffold.

A scaffold in Rails is a full set of models, database migration for that model, a controller to manipulate it, views to view and manipulate the data, and a test suite for each of the above. Our Movie model will have the following fields

• title - string
• image_url - string
• trailer_url - string
• movie_url - string
• status - integer (As this will be an enum with values yet_to_watch, watching, watched)
• release_date - datetime
• watched_date - datetime

rails g scaffold Movie title:string image_url:string trailer_url:string movie_url:string status:integer release_date:datetime watched_date:datetime

This will generate the following files with Course Model, Views & Controller.

      invoke  active_record
      create    db/migrate/20210819042947_create_movies.rb
      create    app/models/movie.rb
      invoke    test_unit
      create      test/models/movie_test.rb
      create      test/fixtures/movies.yml
      invoke  resource_route
       route    resources :movies
      invoke  scaffold_controller
      create    app/controllers/movies_controller.rb
      invoke    erb
      create      app/views/movies
      create      app/views/movies/index.html.erb
      create      app/views/movies/edit.html.erb
      create      app/views/movies/show.html.erb
      create      app/views/movies/new.html.erb
      create      app/views/movies/_form.html.erb
      invoke    test_unit
      create      test/controllers/movies_controller_test.rb
      create      test/system/movies_test.rb
      invoke    helper
      create      app/helpers/movies_helper.rb
      invoke      test_unit
      invoke    jbuilder
      create      app/views/movies/index.json.jbuilder
      create      app/views/movies/show.json.jbuilder
      create      app/views/movies/_movie.json.jbuilder
      invoke  assets
      invoke    coffee
      create      app/assets/javascripts/movies.coffee
      invoke    scss
      create      app/assets/stylesheets/movies.scss
      invoke  scss
      create    app/assets/stylesheets/scaffolds.scss

Database Migration

• Scaffold command also generated database migration for creating Movie table at db/migrate/20210819042947_create_movies.rb

class CreateMovies < ActiveRecord::Migration[5.2]
  def change
    create_table :movies do |t|
      t.string :title
      t.string :image_url
      t.string :trailer_url
      t.string :movie_url
      t.integer :status
      t.datetime :release_date
      t.datetime :watched_date

      t.timestamps
    end
  end
end

• Let's execute database migration using rails db:migrate command.

➜  binged git:(master) ✗ rails db:migrate
== 20210819042947 CreateMovies: migrating =====================================
-- create_table(:movies)
   -> 0.0008s
== 20210819042947 CreateMovies: migrated (0.0008s) ============================

Change Application Root

• Now our migration is completed. Let's point our application home page to the Movie#Index page.
• Update config/routes.rb to point root to course controller index action.

Rails.application.routes.draw do
  resources :movies
  root 'movies#index'
end

Integrate Bootstrap

• Import Bootstrap CSS and dependent js files in app/views/layouts/application.html.erb

<!DOCTYPE html>
<html>
  <head>
    <%= csrf_meta_tags %>
    <%= csp_meta_tag %>

    <%= stylesheet_link_tag    'application', media: 'all', 'data-turbolinks-track': 'reload' %>
    <%= javascript_include_tag 'application', 'data-turbolinks-track': 'reload' %>

    <!-- Required meta tags -->
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">

    <!-- Bootstrap CSS -->
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.1/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-+0n0xVW2eSR5OomGNYDnhzAbDsOXxcvSN1TPprVMTNDbiYZCxYbOOl7+AMvyTG2x" crossorigin="anonymous">

    <title>Binged - Movie Tracker</title>

  </head>

  <body>
    <div class="container">
     <%= yield %>
    </div>
    <!-- Option 1: Bootstrap Bundle with Popper -->
    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.0.1/dist/js/bootstrap.bundle.min.js" integrity="sha384-gtEjrD/SeCtmISkJkNUaaKMoLD0//ElJ19smozuHV6z3Iehds+3Ulb9Bn9Plx0x4" crossorigin="anonymous"></script>
  </body>
</html>

Add Navigation Bar

• Let's add a navigation bar to all pages. Adding this in the application layout will take care of loading the navigation bar on all web pages.

• create file app/views/layouts/_navbar.html.erb with the following HTML content.

<style>
  .theme-color {
    background-color: #800080;
  }
  .theme-btn {
    border-color: #800080;
  }
</style>

<nav class="navbar navbar-expand-lg navbar-dark theme-color">
  <div class="container-fluid">
    <a class="navbar-brand" href="/">Binged</a>
    <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarNavAltMarkup" aria-controls="navbarNavAltMarkup" aria-expanded="false" aria-label="Toggle navigation">
      <span class="navbar-toggler-icon"></span>
    </button>
    <div class="collapse navbar-collapse" id="navbarNavAltMarkup">
      <div class="navbar-nav">
        <a class="nav-link active" aria-current="page" href="/movies">Movies</a>
      </div>
    </div>
  </div>
</nav>

• Now render this navbar in app/views/layouts/application.html.erb . Add <%= render 'layouts/navbar' %> in application layout <body> as follows.

<body>
    <%= render 'layouts/navbar' %>
    <div class="container">
     <%= yield %>
    </div>
    ..
    ..
</body>

Add Movie status Select option

We have the status field in the Movie Model. Now we want this to have only 2 values for this.

• yet_to_watch - use this status if u are yet to watch the movie and it is on your wishlist.
• watching - use this status if u are currently watching the movie.

• watched - use this status if u already watched the movie.

• Let's add status enum in app/models/movie.rb as follows.

class Movie < ApplicationRecord
  enum status: [:yet_to_watch, :watching, :watched]
end

• After adding the status field as enum now you can query Movies by status as follows which will query movies by status.

➜  binged git:(master) ✗ rails c
Running via Spring preloader in process 78801
Loading development environment (Rails 5.2.6)
irb(main):001:0> Movie.yet_to_watch
  Movie Load (0.4ms)  SELECT  "movies".* FROM "movies" WHERE "movies"."status" = ? LIMIT ?  [["status", 0], ["LIMIT", 11]]
=> #<ActiveRecord::Relation []>
irb(main):002:0> Movie.watched
  Movie Load (0.1ms)  SELECT  "movies".* FROM "movies" WHERE "movies"."status" = ? LIMIT ?  [["status", 2], ["LIMIT", 11]]
=> #<ActiveRecord::Relation []>

• Update the status form field to select in app/views/movies/_form.html.erb

  <div class="field">
    <%= form.label :status %>
    <%= form.select :status, Movie.statuses.keys.map { |s| [s.humanize, s]} %>
  </div>

• After adding the above changes your create form will look like this http://localhost:3000/movies/new

Styling Course Forms

Now we will add styling to our Movie Index, Create, Edit forms.

1. Add Styles to Edit/Create Form

• Change app/views/movies/_form.html.erb to the following HTML.

<%= form_with(model: movie, local: true) do |form| %>
  <% if movie.errors.any? %>
    <div id="error_explanation">
      <h2><%= pluralize(movie.errors.count, "error") %> prohibited this movie from being saved:</h2>

      <ul>
      <% movie.errors.full_messages.each do |message| %>
        <li><%= message %></li>
      <% end %>
      </ul>
    </div>
  <% end %>

  <div class="field">
    <%= form.label :title %>
    <%= form.text_field :title , class: "form-control" %>
  </div>

  <div class="field">
    <%= form.label :image_url %>
    <%= form.text_field :image_url, class: "form-control"  %>
  </div>

  <div class="field">
    <%= form.label :trailer_url %>
    <%= form.text_field :trailer_url, class: "form-control"  %>
  </div>

  <div class="field">
    <%= form.label :movie_url %>
    <%= form.text_field :movie_url , class: "form-control" %>
  </div>

  <div class="field">
    <%= form.label :status %>
    <%= form.select :status, Movie.statuses.keys.map { |s| [s.humanize, s]} , class: "form-select" %>
  </div>

  <div class="field">
    <%= form.label :release_date %>
    <%= form.datetime_select :release_date , class: "form-control"  %>
  </div>

  <div class="field">
    <%= form.label :watched_date %>
    <%= form.datetime_select :watched_date , class: "form-control" %>
  </div>

  <div class="actions">
    <%= form.submit 'Submit' , class: "btn btn-primary theme-color" %>
  </div>
<% end %>

• Change app/views/movies/edit.html.erb to the following HTML.

<h1>Editing Movie</h1>

<%= render 'form', movie: @movie %>

<%= link_to 'Show', @movie , class: "btn btn-primary theme-color"%> |
<%= link_to 'Back', movies_path , class: "btn btn-primary theme-color"%>

After styling, Edit Movie Form Looks like this.

2. Add Styles to Show Form

• Change app/views/movies/show.html.erb to the following HTML.

<p id="notice"><%= notice %></p>

<br/> <br/>

<div class="card">
  <div class="card-header">
    <%= @movie.title %>  
  </div>

  <div class="card-body">
    <p>      
      <h5 class="card-title">
        <strong>Title:</strong>
        <%= @movie.title %>
      </h5>
    </p>

    <p>      
      <h5 class="card-title">
        <strong>Status:</strong>
        <%= @movie.status.humanize %>
      </h5>
    </p>

    <p>      
      <h5 class="card-title">
        <strong>Released On:</strong>
        <%= @movie.release_date.to_formatted_s %>
      </h5>
    </p>

    <% if @movie.watched? %>
      <p>      
        <h5 class="card-title">
          <strong>Watched On:</strong>
          <%= @movie.watched_date.to_formatted_s %>
        </h5>
      </p>
    <% end %>

    <p>
      <strong>Trailer : </strong>
      <h5 class="card-title">        
          <iframe width="560" height="315" src="<%= @movie.trailer_url %>" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>
      </h5>
    </p>

    <p>
      <strong>Image : </strong>
      <h5 class="card-title">        
        <img  width="600" height="600" src="<%= @movie.image_url %>"/>
      </h5>
    </p>

  </div>
</div>  

<br/>

<%= link_to 'Edit', edit_movie_path(@movie) , class: "btn btn-outline-primary theme-btn"%> |
<%= link_to 'Back', movies_path , class: "btn btn-outline-primary theme-btn"%>

<br/><br/>

• After styling, Show Movie Form Looks like this.

3. Add Styles to the movies List page

• Now we reached the final stage of our project. We just need to style our Home page. i.e Movies Listing Page.

• Create a new file app/views/movies/_card_section_title.html.erb with the following HTML.

<div class="row">
    <div class="card border-light" >
      <div class="card-body">
        <h3 class="card-title" style="color: #800080;"><%= section %></h3>
      </div>
    </div>
</div>
<br/>

• Create a new file app/views/movies/_movie_cards.html.erb with the following HTML.

<div class="row row-cols-1 row-cols-md-4 g-4">
  <% movies.each do |movie| %>
    <div class="card border-dark">
      <img src="<%= movie.image_url %>" class="card-img-top" alt="<%= movie.title %>">
      <div class="card-body">
        <h5 class="card-title"><a href="<%= movie.movie_url%>" style="color: #800080;"><%= movie.title %></a></h5>
      </div>
      <ul class="list-group list-group-flush">
          <li class="list-group-item"><strong>Release Date : </strong><%= movie.release_date.strftime('%d-%b-%Y') %></li>
          <% if movie.watched? %>
            <li class="list-group-item"><strong>Watched On : </strong><%= movie.watched_date.strftime('%d-%b-%Y') %></li>
          <% end %>
      </ul>
      <div class="card-body">
        <%= link_to 'Show', movie, class: "card-link", style: "color: #800080;" %>
        <%= link_to 'Edit', edit_movie_path(movie) , class: "card-link", style: "color: #800080;" %>
        <%= link_to 'Delete', movie, method: :delete, data: { confirm: 'Are you sure?' }, class: "card-link" , style: "color: #800080;" %>

      </div>
    </div>
  <% end %>
</div>

<br/>

• Update file app/views/movies/index.html.erb to the following HTML.

<p id="notice"><%= notice %></p>

<% if Movie.yet_to_watch.length > 0 %>
  <%= render 'movies/card_section_title', section: "Your Movies Watchlist" %>
  <%= render 'movies/movie_cards', movies: Movie.yet_to_watch %>
<% end %>

<% if Movie.watching.length > 0 %>
  <%= render 'movies/card_section_title', section: "Movies You Are Watching Now" %>
  <%= render 'movies/movie_cards', movies: Movie.watching %>
<% end %>

<% if Movie.watched.length > 0 %>
  <%= render 'movies/card_section_title', section: "Movies You Watched" %>
  <%= render 'movies/movie_cards', movies: Movie.watched %>
<% end %>


<br>

<%= link_to 'New Movie', new_movie_path , class: "btn theme-btn" %>

• Add Create New Movie link in navigation bar app/views/layouts/_navbar.html.erb

<style>
  .theme-color {
    background-color: #800080;
  }
  .theme-btn {
    border-color: #800080;
  }
  .theme-font {
    color: #800080;
  }
</style>

<nav class="navbar navbar-expand-lg navbar-dark theme-color">
  <div class="container-fluid">
    <a class="navbar-brand" href="/">Binged</a>
    <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarNavAltMarkup" aria-controls="navbarNavAltMarkup" aria-expanded="false" aria-label="Toggle navigation">
      <span class="navbar-toggler-icon"></span>
    </button>
    <div class="collapse navbar-collapse" id="navbarNavAltMarkup">
      <div class="navbar-nav">
        <a class="nav-link active" aria-current="page" href="/movies">Movies</a>
        <a class="nav-link active" aria-current="page" href="/movies/new">New Movie</a>
      </div>
    </div>
  </div>
</nav>

• After Styling Movies Index Page, It finally looks like this :)

Hope you enjoyed this tutorial...!!

Find out the complete code in Github here. If you like this, please give star for this Github repository.

Thank you for reading

Hope you find these resources useful. If you like what you read and want to see more about system design, microservices, and other technology-related stuff... You can follow me on

• Twitter - Follow @vishnuchi

For example, your code could read the network locations from a configuration file that’s occasionally updated. But in a modern, cloud-based microservices application, it’s usually not that simple. It is much more dynamic.

Service instances have dynamically assigned network locations. Moreover, the set of service instances changes dynamically because of autoscaling, failures, and upgrades. Consequently, your client code must use service discovery.

What is Service Discovery?

From the above image you can see, you can’t statically configure a client with the IP addresses of the services. Instead, an application must use a dynamic service discovery mechanism.

Service discovery is conceptually quite simple: its key component is a service registry, which is a database of the network locations of an application’s service instances.

The service discovery mechanism updates the service registry when service instances start and stop. When a client invokes a service, the service discovery mechanism queries the service registry to obtain a list of available service instances and routes the request to one of them.

In this article, I will mention about 4 service discovery patterns that you should consider for your microservices.

• 1. Self Registration Pattern
• 2. Client Side Discovery Pattern
• 3. Server Side Discovery Pattern
• 4. 3rd Party Registration Pattern

The services and their clients interact directly with the service registry:

1. Self Registration Pattern

The first pattern is the Self Registration pattern. A service instance invokes the service registry’s registration API to register its network location. It may also supply a health check URL.

The health check URL is an API end-point that the service registry invokes periodically to verify that the service instance is healthy and available to handle requests.

A service registry may require a service instance to periodically invoke a “heartbeat” API in order to prevent its registration from expiring.

A service instance registers itself with the service registry. Find out more details here.

2. Client Side Discovery Pattern

The second pattern is the Client-side discovery pattern. When a service client wants to invoke a service, it queries the service registry to obtain a list of the service’s instances.

To improve performance, a client might cache the service instances. The service client then uses a load-balancing algorithm, such as a round-robin or random, to select a ser- vice instance. It then makes a request to a select service instance.

Find out more details here

The deployment infrastructure handles service discovery:

3. Server Side Discovery Pattern

In this pattern, Instead of a client querying the service registry, it makes a request to a DNS name, which resolves to a request router that queries the service registry and load-balances requests.

A client makes a request to a router, which is responsible for service discovery. Find out more details here.

4. 3rd Party Registration Pattern

In this pattern, Instead of a service registering itself with the service registry, a third party called the registrar, which is typically part of the deployment platform, handles the registration.

Service instances are automatically registered with the service registry by a third party. Find out more details here.

Advantages of platform-provided service discovery:

The key benefit of platform-provided service discovery is that all aspects of service discovery are entirely handled by the deployment platform. Neither the services nor the clients contain any service discovery code. Consequently, the service discovery mechanism is readily available to all services and clients regardless of which language or framework they’re written in.

Disadvantages of platform-provided service discovery:

One drawback of platform-provided service discovery is that it only supports the discovery of services that have been deployed using the platform. For example, Kubernetes-based discovery only works for services running on Kubernetes.

Thank you for reading

Hope you find these resources useful. If you like what you read and want to see more about system design, microservices, and other technology-related stuff... You can follow me on

• Twitter - Follow @vishnuchi

• Subscribe to my weekly newsletter here.

I will list down kubectl commands in the sections below as a quick reference to work with Kubernetes.

• List Resources
• Create Resources
• Update Resources
• Display the State of Resources
• Delete Resources
• Execute Command
• Print Container Logs
• Modify Kubeconfig Files

List Resources

• Get list of all namespaces

  kubectl get namespaces
  

• Get list of all pods

  kubectl get pods
  

• Get list of all pods with detailed information like IP, Node Name etc...

  kubectl get pods -o wide
  

• Get list of all pods running on a particular node server

  kubectl get pods --field-selector=spec.nodeName=[server-name]
  

• Get list of all replication controllers and services

  kubectl get replicationcontroller,services
  

• Get list of daemonsets

  kubectl get daemonset
  

Create Resources

• Create a new namespace

  kubectl create namespace [namespace-name]
  

• Create a new namespace from JSON or YAML file.

  kubectl create –f [filename]
  

Update Resources

To apply or update a resource use the kubectl apply command.

• Create a new service with the definition contained in [service-config].yaml

  kubectl apply -f [service-config].yaml
  

• Create a new replication controller with the definition contained in [controller-config].yaml

  kubectl apply -f [controller-config].yaml
  

• Create the objects defined in any .yaml, .yml, or .json file in a directory

  kubectl apply -f [yaml-file/directory-name]
  

• Edit a service config

  kubectl edit svc/[service-name]
  

  Above command opens the file in your default editor. To choose another editor, specify it in front of the command:

  KUBE_EDITOR=”[editor-name]” kubectl edit svc/[service-name]
  

Display the State of Resources

• Get Details about Particular Node

  kubectl describe nodes [node-name]
  

• Get Details about a Particular pod

  kubectl describe pods [pod-name]
  

• Get Details about a Particular pod whose name and type are listed in pod.json

  kubectl describe –f pod.json
  

• Get Details about a Particular pod managed by a specific replication controller

  kubectl describe pods [replication-controller-name]
  

• Get Details about all pods

  kubectl describe pods
  

Delete Resources

• Delete a pod using the name and type mentioned in pod.yaml

  kubectl delete -f pod.yaml
  

• Delete all pods and services with a specific label

  kubectl delete pods,services -l [label-key]=[label-value]
  

• Delete all pods

  kubectl delete pods --all
  

Execute Command

• Get output from a command run on the first container in a pod

  kubectl exec [pod-name] -- [command]
  

• Get output from a command run on a specific container in a pod

  kubectl exec [pod-name] -c [container-name] -- [command]
  

• Run /bin/bash from a specific pod. The received output comes from the first container

  kubectl exec -ti [pod-name] -- /bin/bash
  

Print Container Logs

• Print Logs from Pod

  kubectl logs [pod-name]
  

• Stream Logs from Pod

  kubectl logs -f [pod-name]
  

• Tail Logs from Pod (Print last 200 logs from pod)

  kubectl logs --tail=200 [pod-name]
  

Modify Kubeconfig Files

kubectl config command lets you view and modify kubeconfig files.

• Get Current Context

  kubectl config current-context
  

• Set cluster entry in kubeconfig

  kubectl config set-cluster [cluster-name] --server=[server-name]
  

• Unset an entry in kubeconfig

  kubectl config unset [property-name]
  

Thank you for reading

Hope you find these resources useful. If you like what you read and want to see more about system design, microservices, and other technology-related stuff... You can follow me on

• Twitter - Follow @vishnuchi

• Subscribe to my weekly newsletter here.

• No of requests per second
• Memory Utilization of application instances
• CPU utilization of application instances
• Disk Utilization of application instances etc...

You also need to be alerted if there’s a problem, such as a failed service instance or a disk filling up, ideally before it impacts a user. If there’s a problem, you need to be able to troubleshoot and identify the root cause.

Many aspects of managing an application in production are outside the scope of the developer, such as monitoring hardware availability and utilization. These are clearly the responsibility of operations. But there are several patterns that you, as a service developer must implement to make your service easier to manage and troubleshoot. Below are 6 key Observable patterns that you need to consider for your Microservice

• Health Check API
• Log Aggregation
• Distributed Tracing
• Exception Tracking
• Application Metrics
• Audit Logging

Health Check API

Expose an endpoint that returns the health of the service.

A service instance needs to be able to tell the deployment infrastructure whether or not it’s able to handle requests. A good solution is for a service to implement a health check endpoint.

For example, implement a GET /health endpoint, which returns 200 if and only if the service is healthy, and 503 otherwise.

The deployment infrastructure periodically invokes this endpoint to determine the health of the service instance and takes the appropriate action if it’s unhealthy.

Log Aggregation

Log service activity and write logs into a centralized logging server, which provides searching and alerting.

Logs are a valuable troubleshooting tool. If you want to know what’s wrong with your application, a good place to start is the log files. But using logs in a microservice architecture is challenging.

Most of the time, the log entries you need are scattered across the log files of the API gateway and several services. The solution is to use log aggregation.

The log aggregation pipeline sends the logs of all of the service instances to a centralized logging server. Once the logs are stored by the logging server, you can view, search, and analyze them. You can also configure alerts that are triggered when certain messages appear in the logs.

Distributed Tracing

Assign each external request a unique ID and trace requests as they flow between services.

A good way to get insight into what your application is doing is to use distributed tracing. Distributed tracing is analogous to a performance profiler in a monolithic application. It records information (Ex: start time and end time) about the tree of service calls that are made when handling a request.

Exception Tracking

Report exceptions to an exception tracking service, which de-duplicates exceptions, alerts developers and tracks the resolution of each exception.

A service should rarely log an exception, and when it does, it’s important that you identify the root cause. The exception might be a symptom of a failure or a programming bug. The traditional way to view exceptions is to look in the logs. You might even configure the logging server to alert you if an exception appears in the log file. A better approach is to use an exception tracking service.

Application Metrics

Services maintain metrics, such as counters and gauges, and expose them to a metrics server

A key part of the production environment is monitoring and alerting. So it's important to have a monitoring system that gathers metrics, which provide critical information about

• Health of an application, from every part of the technology stack.
• Metrics range from infrastructure-level metrics, such as CPU, memory, and disk utilization, to application-level metrics, such as service request latency and a number of requests executed, etc...

Ex: Newrelic, Datadog, etc...

Audit Logging

Log user actions

The purpose of audit logging is to record each user’s actions. An audit log is typically used to help customer support, ensure compliance, and detect suspicious behavior. Each audit log entry records the identity of the user, the action they performed, and the business objects.

Thank you for reading

Hope you find these resources useful. If you like what you read and want to see more about system design, microservices, and other technology-related stuff... You can follow me on

• Twitter - Follow @vishnuchi

• Subscribe to my weekly newsletter here.

The communication between microservices can be one of the following two ways.

• Synchronous Communication
• Asynchronous Communication

Synchronous Communication

Synchronous Communication is real-time communication between two services. The caller service will wait until it gets the response from the invoked service within the configured timeout threshold.

Services can use synchronous request/response-based HTTP communication mechanisms, such as

• REST
• gRPC

REST

REST is an acronym for REpresentational State Transfer. It is an architectural style for distributed hypermedia systems and was first presented by Roy Fielding in 2000.

REST also does have it's own 6 guiding constraints which must be satisfied if an interface needs to be referred to as RESTful.

• 1. Uniform interface - A resource in the system should have only one logical URI, and that should provide a way to fetch related or additional data.
• 2. Client-server - This constraint essentially means that client application and server application MUST be able to evolve separately without any dependency on each other. A client should know only resource URIs, and that’s all.
• 3. Stateless - Make all client-server interactions stateless. The server will not store anything about the latest HTTP request the client made. It will treat every request as new. No session, no history.
• 4. Cacheable - In REST, caching shall be applied to resources when applicable, and then these resources MUST declare themselves cacheable. Caching can be implemented on the server or client-side
• 5. Layered system - REST allows you to use a layered system architecture where you deploy the APIs on server A, and store data on server B and authenticate requests in Server C, for example. A client cannot ordinarily tell whether it is connected directly to the end server or an intermediary along the way.
• 6. Code on demand (optional) - Most of the time, you will be sending the static representations of resources in the form of XML or JSON. But when you need to, you are free to return executable code. e.g., clients may call your API to get a UI widget rendering code. It is permitted.

Find out more details about REST constraints here.

gRPC

gRPC is a modern, open-source, high-performance remote procedure call (RPC) framework that can run anywhere. gRPC enables client and server applications to communicate transparently and simplifies the building of connected systems. It was initially developed at Google in 2015 as the next generation of the RPC infrastructure Stubby.

In gRPC, a client application can directly call a method on a server application on a different machine as if it were a local object, making it easier for you to create distributed applications and services.

On the server-side, the server implements this interface and runs a gRPC server to handle client calls. On the client-side, the client has a stub (referred to as just a client in some languages) that provides the same methods as the server.

By default, gRPC uses Protocol Buffers, Google’s mature open source mechanism for serializing structured data (although it can be used with other data formats such as JSON).

Find out more details about gRPC here.

Asynchronous Communication

Asynchronous Communication is when you send a message without expecting an immediate response from the invoked service. The caller service will just send the request and invoked service will queue the request and process it.

Services can use asynchronous, message-based communication mechanisms such as

• Message Queues
• Pub/Sub

Message Queues

A message queue is an architecture that provides asynchronous communication, allowing microservices to interact with each other without coupling. These messages are then stored (in memory or persisted) in a queue and processed by another microservice (called the Consumer).

Below are the few popular Messaging Queues that can be used for your application.

• RabbitMQ
• Apache ActiveMQ
• IBM MQ

Pub/Sub

Pub/Sub enables you to create systems of event producers and consumers, called publishers and subscribers. Publishers communicate with subscribers asynchronously by broadcasting events, rather than by synchronous calls.

Publishers send events to the Pub/Sub service, without regard to how or when these events will be processed. Pub/Sub then delivers events to all services that need to react to them.

Compared to synchronous communication through REST or RPCs, where publishers must wait for subscribers to receive the data, such asynchronous integration increases the flexibility and robustness of the system overall.

Below are the few popular pub/sub services that can be used for your application.

• Apache Kafka
• Google pub/sub
• AWS SNS
• Redis pub/sub

References:

• https://restfulapi.net/rest-architectural-constraints/
• https://grpc.io/docs/what-is-grpc/introduction/

Thank you for reading

Hope you find these resources useful. If you like what you read and want to see more about system design, microservices, and other technology-related stuff... You can follow me on

• Twitter - Follow @vishnuchi

• Subscribe to my weekly newsletter here.

Search engines are able to return results quickly even with millions of records by indexing every data record they find. In this blog post, I will list 5 popular open-source search engines which can be used to build search functionality in your website.

• Apache Lucene
• Apache Solr
• Elasticsearch
• MeiliSearch
• Typesense

Apache Lucene

Apache Lucene is a free and open-source search engine software library, originally written completely in Java. It is supported by the Apache Software Foundation and is released under the Apache Software License. It is a technology suitable for nearly any application that requires full-text search, especially cross-platform.

Below are some of the key features of Apache Lucene.

• Data Indexing
• Search
• Spellchecking
• Keyword Highlighting
• Advanced analysis/tokenization capabilities.

Apache Solr

Apache Solr is the popular, blazing-fast, open-source enterprise search platform built on Apache Lucene. Solr is a standalone search server with a REST-like API. You can put documents in it (called "indexing") via JSON, XML, CSV, or binary over HTTP. You query it via HTTP GET and receive JSON, XML, CSV, or binary results.

Below are some of the key features of Solr.

• Advanced Full-Text Search Capabilities : Solr enables powerful matching capabilities including phrases, wildcards, joins, grouping, and much more across any data type.

• Optimized for High Volume Traffic: Solr is proven at extremely large scales the world over

• Comprehensive Administration Interfaces: Solr provides a responsive administrative user interface to make it easy to control your Solr instances.

• Easy Monitoring: Solr publishes loads of metric data via JMX which helps to get more insights about your Solr instances.

Elasticsearch

Elasticsearch is a distributed, RESTful search and analytics engine capable of addressing a growing number of use cases. It is built based on the Lucene library. It provides a distributed, multitenant-capable full-text search engine with an HTTP web interface and schema-free JSON documents.

Elasticsearch provides key features like Advanced Full-Text Search Capabilities like Data indexing, Search capabilities including phrases, wildcards, auto suggestions, filters & facets, etc... Elasticsearch can also be used for other use-cases like

• Logs - Storing logs via ELK (Elasticsearch, Logstash, Kibana)
• Metrics - Monitor and Visualise your system metrics
• APM - Get insights into your application performance
• App Search - Search across your documents, geodata, and more.

MeiliSearch

MeiliSearch is an open-source, blazingly fast and hyper-relevant search engine that will improve your search experience. It provides an extensive toolset for customization. It works out-of-the-box with a preset that easily answers the needs of most applications. Communication is done with a RESTful API because most developers are already familiar with its norms.

Below are the few key features of MeiliSearch.

• Synonyms : Ability to create synonyms for a better search experience.
• Highlight: With highlight, users understand their search results and act upon them.
• Custom Relevancy: It gives you the possibility to add new sorting rules. You can order results by date, likes, whatever suits your dataset.
• Filters: Improve your search query by adding custom filters.
• Faceting: Empower users to drill down on search results and find what they need faster.

Typesense

Typesense is a fast, typo-tolerant search engine for building delightful search experiences. It claims that it is an Easier-to-Use ElasticSearch Alternative & an Open Source Algolia Alternative.

Below are few key features of Typesense

• Typo Tolerance: Handles typographical errors elegantly, out-of-the-box.
• Simple and Delightful: Simple to set up, integrate with, operate, and scale. -⚡ Blazing Fast: Built-in C++. Meticulously architected from the ground-up for low-latency (<50ms) instant searches.
• Tunable Ranking: Easy to tailor your search results to perfection. Sorting: Sort results based on a particular field at query time (helpful for features like "Sort by Price").
• Faceting & Filtering: Drill down and refine results.
• Grouping & Distinct: Group similar results together to show more variety.
• Federated Search: Search across multiple collections (indices) in a single HTTP request.
• Synonyms: Define words as equivalents of each other, so searching for a word will also return results for the synonyms defined.
• Geo search - Search and sort by results around a geographic location

Other Popular Enterprise Search Engines

Below are a few other popular Enterprise Search Engines that are not free

• Algolia
• Swiftype
• Klevu

Thank you for reading

Hope you find these resources useful. If you like what you read and want to see more about system design, microservices, and other technology-related stuff... You can follow me on

• Twitter - Follow @vishnuchi

• Subscribe to my weekly newsletter here.

• Lifecycle Commands
• Starting and Stopping Containers
• Docker Image Commands
• Docker Container And Image Information
• Network Commands

Lifecycle Commands

• Create a container (without starting it):

  docker create [IMAGE]
  

• Rename an existing container

  docker rename [CONTAINER_NAME] [NEW_CONTAINER_NAME]
  

• Run a command in a new container

  docker run [IMAGE] [COMMAND]
  

• Remove container after it exits

  docker run --rm [IMAGE]
  

• Start a container and keep it running

  docker run -td [IMAGE]
  

• Start a container and creates an interactive bash shell in the container

  docker run -it [IMAGE]
  

• Create, Start, and run a command inside the container and remove the container after executing command.

  docker run -it-rm [IMAGE]
  

• Execute command inside already running container.

  docker exec -it [container]
  

• Delete a container (if it is not running)

  docker rm [CONTAINER]
  

• Update the configuration of the container

  docker update [CONTAINER]
  

Starting and Stopping Containers

• Start Container

  docker start [CONTAINER]
  

• Stop running Container

  docker stop [CONTAINER]
  

• Stop running Container and start it again

  docker restart [CONTAINER]
  

• Pause processes in a running container

  docker pause [CONTAINER]
  

• Unpause processes in a running container

  docker unpause [CONTAINER]
  

• Block a container until others stop

  docker wait [CONTAINER]
  

• Kill a container by sending a SIGKILL to a running container

  docker kill [CONTAINER]
  

• Attach local standard input, output, and error streams to a running container

  docker attach [CONTAINER]
  

Docker Image Commands

• Create an image from a Dockerfile

  docker build [URL/FILE]
  

• Create an image from a Dockerfile with Tags

  docker build -t <tag> [URL/FILE]
  

• Pull an image from a registry

  docker pull [IMAGE]
  

• Push an image to a registry

  docker push [IMAGE]
  

• Create an image from a tarball

  docker import [URL/FILE]
  

• Create an image from a container

  docker commit [CONTAINER] [NEW_IMAGE_NAME]
  

• Remove an image

  docker rmi [IMAGE]
  

• Load an image from a tar archive or stdin

  docker load [TAR_FILE/STDIN_FILE]
  

• Save an image to a tar archive

  docker save [IMAGE] > [TAR_FILE]
  

Docker Container And Image Information

• List running containers

  docker ps
  

• Lists both running containers and ones that have stopped

  docker ps -a
  

• List the logs from a running container

  docker logs [CONTAINER]
  

• List low-level information on Docker objects

  docker inspect [OBJECT_NAME/ID]
  

• List real-time events from a container

  docker events [CONTAINER]
  

• Show port mapping for a container

  docker port [CONTAINER]
  

• Show running processes in a container

  docker top [CONTAINER]
  

• Show live resource usage statistics of container

  docker stats [CONTAINER]
  

• Show changes to files (or directories) on a filesystem

  docker diff [CONTAINER]
  

• List all images that are locally stored with the docker engine

  docker [image] ls
  

• Show the history of an image

  docker history [IMAGE]
  

Network Commands

• List networks

  docker network ls
  

• Remove one or more networks

  docker network rm [NETWORK]
  

• Show information on one or more networks

  docker network inspect [NETWORK]
  

• Connects a container to a network

  docker network connect [NETWORK] [CONTAINER]
  

• Disconnect a container from a network

  docker network disconnect [NETWORK] [CONTAINER]
  

Thank you for reading

Hope you find these resources useful. If you like what you read and want to see more about system design, microservices, and other technology-related stuff... You can follow me on

• Twitter - Follow @vishnuchi

• Subscribe to my weekly newsletter here.

1. Freecodecamp

Freecodecamp provides multiple courses starting from Python, Responsive Web Design, Javascript Algorithms & Data Structures, React, Machine Learning, Data Analysis, etc...

They also offer tutorials/courses on how to build real-world applications in multiple programming languages like Ruby on Rails, Python, Node Js, etc... in their YouTube Channel and its pretty popular one.

2. Coursera

Coursera is a popular website where you can find courses from popular Ivy League colleges. It provides courses in multiple subjects ranging from Programming Languages, Data Engineering, Machine Learning, Mobile Development, Cloud Computing, etc...

It offers Paid certifications and Free courses as well. If you want to just learn the contents of the course irrespective of certification you can just Audit the course.

3. Udemy

Udemy is the most popular website where most of the developers and people from the tech community refer to. Udemy is pretty much like a marketplace of courses where Instructors can signup and create courses. If you are an expert in any domain you can create a course on the same and upload it in Udemy.

Udemy has many great courses for almost all Programming Languages, Databases, Mobile development, Frontend, and Backend technologies.

Most of the Udemy Courses are paid courses. It offers great discounts on selected courses most of the time. So make sure u check out offers for your course before you purchase it.

4. LinkedIn Learning

LinkedIn Learning offers video courses often taught by domain and industry experts in business, leadership, creative, and software technologies. It is one of the subsidiaries of LinkedIn. Most of the courses in LinkedIn Learning fall into 3 categories.

• Business
• Creative
• Technology

It offers paid courses and the first month of your LinkedIn learning is free.

5. Pluralsight

Pluralsight offers a variety of video training courses for software developers, IT administrators, and creative professionals. It provides multiple products like

• Paths - Where courses are curated by Experts based on difficulty level to learn the skill.
• Course Discussions - Where you can engage and discuss with the community and experts to discuss course-related topics.

It offers paid courses and the first 10 days of free subscription on signup.

6. Udacity

Udacity offers Nanodegree programs that are built in partnership with the tech companies and taught by industry leaders like

• Google
• Amazon
• IBM
• Microsoft
• Intel etc...

It provides courses in subjects like Programming, Databases, Machine Learning, Artificial Intelligence, Robotics, Self-Driving Cars, etc...It also provides financial aid to the learners based on their merit and performance in the Nanodegree Program.

7. FutureLearn

FutureLearn is a UK-based digital educational platform founded in 2012. It is a Massive Open Online Course learning platform and it has almost 250 UK + International partners offering courses in multiple subjects ranging from Business, Creative Arts, Healthcare, IT & Computer Science, Law, Literature, etc...

It offers a flexible monthly subscription plan and a 7-day free trial as well.

8. Datacamp

Datacamp provides specialization courses related to

• Data Engineering
• Machine Learning
• Artificial Intelligence

It provides Courses, Career and Skill Tracks on Data courses with R, Python, etc...If you are someone who is looking for Data Engineering related courses, this is the best place to start. It offers Personal and Business plans with different pricing levels.

9. Educative

Educative provides technology courses where you can learn without the hassle of environment setup or videos. It is trusted by the learners working in tech giants like Microsoft, Netflix, Facebook, Google, etc... (as mentioned on the website).

Learners can buy a monthly/annual subscription plan or can purchase the individual course.

10. Treehouse

Treehouse or is an online technology school that offers beginner to advanced courses in

• Web Design
• Web Development
• Mobile Development
• Game Development. Its courses are aimed at beginners looking to learn coding skills for a career in the tech industry.

It offers a 7-day free trial as well after which you need to subscribe for monthly plans.

Hope you like the article.

Thank you for reading

Hope you find these resources useful. If you like what you read and want to see more about system design, microservices, and other technology-related stuff... You can follow me on

• Twitter - Follow @vishnuchi

• Subscribe to my weekly newsletter here.