CRUD operations
CRUD operations are the four basic operations that any data storage
application must be able to perform: Create, Read, Update, and Delete.
Create: Add new data to the storage system.
Read: Retrieve data from the storage system.
Update: Modify existing data in the storage system.
Delete: Remove data from the storage system.
CRUD operations are used in a wide variety of applications, including
relational databases, NoSQL databases, file systems, and content
management systems.
Features Of Mongo DB
Schema-less: MongoDB does not require a predefined schema for
documents. This gives developers a lot of flexibility in how they store and
retrieve data.
Scalable: MongoDB can be scaled horizontally by adding more servers.
This makes it a good choice for applications that need to handle large
amounts of data and traffic.
High performance: MongoDB is designed for high performance. It uses a
variety of techniques, such as in-memory caching and efficient query
execution, to achieve good performance.
Replication: MongoDB supports replication, which allows you to create
multiple copies of your data for redundancy and scalability.
Difference between Virtual Machines and containers
Virtualization level Virtualizes hardware Virtualizes operating system
Each VM has its own VMs share the host operating
Operating system
operating system system
Uses more resources Uses fewer resources (CPU,
Resource usage
(CPU, memory, storage) memory, storage)
Containers are more portable,
VMs can be ported
as they can run on any
Portability between different
platform that has the Docker
hardware platforms
runtime installed
What is Kubernetes
Kubernetes, often abbreviated as K8s, is an open-source container
orchestration platform.
Container Orchestration: Kubernetes facilitates the automated deployment,
scaling, and management of containerized applications. Containers are
lightweight, portable units that package application code and dependencies
together.
Scalability: Kubernetes allows applications to scale seamlessly by
automatically adjusting the number of container instances based on
demand.
Automated Deployment: Kubernetes simplifies the deployment process by
automating tasks such as rolling updates, rollbacks, and distribution of
application components.
Management of Containers: Kubernetes provides tools for deploying,
managing, and scaling containerized applications.
Kubernetes Architecture
Master Node Components :
kube-apiserver: The API server is the central management point of the entire
Kubernetes control plane. It exposes the Kubernetes API, which is used to
manage the cluster. All administrative tasks and communication with other
components occur through the API server.
etcd: etcd is a distributed key-value store that serves as the cluster's
database. It stores the configuration data, ensuring consistency and
reliability across the cluster. The etcd data is crucial for maintaining the state
of the entire Kubernetes cluster.
Worker Node Components :
kubelet: The kubelet is an agent that runs on each worker node and is
responsible for communicating with the Master Node. It ensures that
containers are running in a Pod, part of a higher-level application abstraction
in Kubernetes.
kube-proxy: The kube-proxy maintains network rules on nodes, enabling
communication between different Pods and external traffic. It performs
packet forwarding, allowing seamless network communication within the
cluster.
Container: A container is a lightweight, standalone, and executable software
package that includes everything needed to run a piece of software, including
the code, runtime, libraries, and system tools. Containers run on a shared
operating system kernel but are isolated from each other.
Docker Daemon: The Docker Daemon is a background process that manages
Docker containers on a host system. It listens for Docker API requests and
manages the building, running, and monitoring of containers.
Docker Client: The Docker Client is the command-line interface (CLI) or API
through which users interact with Docker. It sends commands to the Docker
Daemon, facilitating actions like building, running, and managing containers.
kubectl create: kubectl create -f [configuration file]
Description: Instantiates and deploys resources in the cluster based on the
configurations provided in a YAML or JSON file.
kubectl get : kubectl get [resource]
Description: Retrieves information about resources, allowing users to view the
current state of Pods, Services, or other components in the cluster.
kubectl apply: kubectl apply -f [configuration file]
Applies configurations from a file to the cluster, creating or updating
resources as needed. This is a versatile command for resource management.
kubectl delete: kubectl delete [resource] [name]
Removes resources from the cluster, terminating Pods, Services, Deployments, or
other objects based on the specified name and resource type.
Cloud Architecture
Frontend : The frontend is the user interface of the cloud application, often
accessible through web browsers or mobile devices. It includes components
responsible for user interaction, presentation, and rendering.
Backend : The backend consists of server-side components that handle
application logic, data processing, and communication with databases or
external services. It's responsible for executing business logic and managing
data.
Database : The database component stores and manages application data. It
could be a relational database, NoSQL database, or a combination, depending
on the application's requirements. The database ensures persistent storage
and retrieval of information.
APIs : APIs (Application Programming Interfaces) facilitate communication
and data exchange between different components of the application. They
enable interaction between the frontend, backend, and external services,
promoting a modular and scalable architecture.
Monolithic Applications
Single Codebase: In a monolithic application, all components, from the user
interface to the data storage and processing, are part of a single codebase.
This simplifies development as there is only one code repository to manage.
Tight Integration: Components of the application are tightly integrated and
communicate with each other directly. Function calls and data access are
typically within the same address space, making it easier to develop and
debug but potentially leading to dependencies between components.
Deployment as a Single Unit: The entire application is deployed as a single
unit. When updates or changes are made, the entire application needs to be
redeployed. This can lead to downtime during deployment and may make it
challenging to scale specific parts of the application independently.
Scalability Challenges: Scaling a monolithic application can be challenging
because all components are part of the same codebase and deployed
together. If one component requires more resources, the entire application
may need to be scaled, even if other components don't require additional
resources.
API Management:
API Management involves the processes, tools, and policies used to create,
publish, and oversee the lifecycle of Application Programming Interfaces
(APIs). It includes aspects such as designing APIs, controlling access,
monitoring usage, and ensuring security.
API Gateway:
An API Gateway is a server that acts as an intermediary between an
application and microservices or backend services. It manages requests,
enforces security policies, performs authentication, and can handle tasks like
rate limiting and logging. The API Gateway streamlines communication
between different components of a system.
Docker Registry: Docker Registry is a centralized repository for storing and
sharing Docker images. Images are used to create containers. The default
public registry is Docker Hub, but organizations can set up private registries
for their own images.