🐍 Python for Backend: Professional Microservices Architecture and High Performance 🚀

📚Comprehensive Technical Glossary 

 ✅ ASGI (Asynchronous Server Gateway Interface): 

The spiritual successor to WSGI. It provides a server interface standard that allows Python applications to handle modern asynchronous protocols such as WebSockets, HTTP/2, and Long Polling. It is the key piece that allows thousands of users to maintain simultaneous connections without exhausting server resources.

 ✅ Pydantic V2:

 An ultra-high-performance data validation engine written in Rust. It uses Python type annotations to enforce strict schemas, performing automatic data cleaning, validation, and type coercion, ensuring that business logic never processes corrupt or malformed data.

 ✅ Event Loop: 

The core of asynchronous execution. It is a scheduler that monitors waiting tasks (I/O). When a task reaches a wait point, the loop suspends it and grants control to another ready task, maximizing CPU time usage.

 ✅ Type Hinting & Static Analysis: 

Formal syntax introduced in PEP 484 that allows declaring the nature of data. Combined with tools like Mypy, it transforms Python into a language with verifiable type safety before execution, eliminating entire classes of logic errors.

 ✅ Global Interpreter Lock (GIL): 

A synchronization mechanism that protects access to Python objects, allowing only one thread to execute bytecode at a time. Understanding it is vital for deciding between concurrency (asynchronous) and parallelism (multiprocessing).

 ✅ Dependency Injection (DI): 

A design pattern where objects do not create their dependencies but receive them from an external source. This facilitates decoupling, modularity, and, fundamentally, the ability to perform unit testing by swapping real services for "mocks."

 ✅ API Idempotency: 

A property that guarantees that performing the same request multiple times produces the same result on the server, avoiding data duplication in cases of network retries, which is essential in financial systems.

 ✅ Coroutines: 

Specialized functions declared with async def that can suspend their execution. They are lighter than operating system threads, allowing millions of them to coexist in a single process.

 ✅ Application Middleware: 

Layers of logic that intercept the lifecycle of an HTTP request. They are used to inject security headers, manage telemetry, perform on-the-fly data compression, or validate access tokens before reaching the final route.

 ✅ Race Condition: 

A critical defect that occurs when two or more operations compete to modify a shared resource at the same time, resulting in an inconsistent or unpredictable data state.

 ✅ Context Managers (with statement): 

A resource management protocol that ensures objects are correctly initialized and finalized (e.g., closing a database connection or a file), even if an exception occurs.

 ✅ Serialization and Deserialization (Marshaling): 

The process of transforming complex Python objects into exchange formats (such as JSON or Protocol Buffers) and vice versa, maintaining data schema integrity.

📍Technical Treatise: 

📌Chapter 1: The role of Python in mission-critical infrastructures and global scale

III

In today's technological landscape, Python has shifted from being a "scripting" language to becoming the engine of services handling petabytes of daily information. Its professional value lies not in raw cycle execution speed but in its ability to act as a high-level "glue layer" that orchestrates complex infrastructures. A backend architect must understand that Python's efficiency emanates from its readability, which reduces long-term maintenance costs and accelerates time-to-market. In this chapter, we analyze why leading companies prefer Python for their business logic layers, integrating low-level libraries (written in C or Rust) for heavy tasks, thus achieving a perfect balance between productivity and power.

📌Chapter 2: Dependency engineering and deterministic management with Poetry

Package management is the foundation of stability for any software. At a professional level, using rudimentary tools like pip and requirements.txt represents a security and instability risk. Poetry revolutionizes this flow through a dependency resolution system based on a compatibility graph. By generating a poetry.lock file, it ensures that every secondary and tertiary library is identical in the development environment and on the production server. This chapter explores how to configure isolated environments, manage supply chain vulnerabilities, and ensure that code implementation is reproducible and free of silent regressions.

📌Chapter 3: Excellence in code quality: PEP 8, Black, and Clean Code

Code quality is a technical metric, not an aesthetic one. Implementing the PEP 8 standard is the baseline, but an executive environment demands total automation. Using Black, the "uncompromising" code formatter, eliminates discussions in code reviews regarding style, allowing the team to focus exclusively on logic and architecture. Coupled with advanced linters like Ruff, this chapter details how to maintain a codebase with low cyclomatic complexity, making it easier for new engineers to integrate into the project with a minimal learning curve and ensuring that technical debt remains under strict control.

📌Chapter 4: Strict typing and enterprise robustness through Type Hints

The biggest historical criticism of Python has been its dynamic nature, which can hide errors until runtime. Modern Type Hints transform this weakness into a strength. By explicitly declaring data types, code becomes a self-documented and verifiable entity. Using Mypy and Pyright in the Continuous Integration (CI) pipeline allows for detecting logic failures before the code reaches production. This chapter delves into how strict typing improves safe refactoring and enables IDEs to provide real-time autocompletion and error analysis, raising software reliability to levels comparable with compiled languages.

📌Chapter 5: Hybrid Architectures: Fusion of OOP and Functional Programming

A high-level backend is not limited to a single paradigm. Object-Oriented Programming (OOP) is ideal for modeling state and domain entities (such as users, orders, or transactions), using patterns like the Repository or Unit of Work. On the other hand, Functional Programming shines in data transformation, where immutability and pure functions prevent unpredictable side effects. This chapter teaches how to design systems where objects manage structure and functions process information, resulting in modular code that is easy to test and highly resilient to business requirement changes.

📌Chapter 6: The asynchronous engine: Deep dive into asyncio and the Event Loop

The performance of modern applications is dictated by efficiency in managing Input/Output (I/O). The asyncio module allows Python to perform multiple tasks "simultaneously" by not blocking the execution thread during network or disk waits. The Event Loop is the heart of this operation; it acts as an intelligent dispatcher that pauses coroutines waiting for data and activates those ready to process. This chapter breaks down the lifecycle of an asynchronous task, how to avoid blocking the loop with synchronous code, and why frameworks like FastAPI achieve superior performance by handling thousands of requests with a fraction of the memory consumption of traditional thread-based models.

📌Chapter 7: Demystifying the GIL and real parallelism strategies

For a Python architect, understanding the Global Interpreter Lock (GIL) is mandatory. Although the GIL prevents multiple threads from executing Python code at the same time, its impact is zero on asynchronous I/O operations. However, for CPU-intensive tasks (such as image processing, encryption, or massive data analysis), this chapter details the implementation of the multiprocessing module. You will learn to create independent processes that bypass the GIL and leverage every physical hardware core available, allowing your application to scale vertically efficiently.

📌Chapter 8: Advanced coroutine management and task optimization

Writing async and await is only the first step. The true professional challenge lies in the orchestration of these tasks. This chapter delves into advanced techniques like asyncio.gather for parallel coroutine execution, reducing the total latency of a request to the time of the slowest task. We also cover timeout management to avoid "zombie" requests, the implementation of concurrency limits using semaphores to avoid saturating external services, and the importance of shields to protect critical tasks from unexpected cancellations during the server lifecycle.

📌Chapter 9: Resilience and exception handling in distributed systems

In a high-level backend, errors are first-class citizens. A professional system must be able to fail gracefully without collapsing completely. This chapter explores the hierarchy of Python exceptions applied to microservices. We analyze the implementation of Retry patterns with Exponential Backoff to handle temporary network failures and the design of Circuit Breakers to isolate failing services and preserve the global health of the ecosystem. The goal is to build resilient applications that maintain data integrity even under partial failure conditions.

📌Chapter 10: Test Engineering: Pytest and the industrial quality standard

Confidence in software deployment is born from a robust and automated test suite. Pytest has consolidated itself as the industry standard for its flexibility and power. This chapter details how to structure unit, integration, and end-to-end tests for asynchronous code using pytest-asyncio. You will learn to use Fixtures to manage test state and the use of advanced Mocks to simulate databases and external APIs, ensuring significant code coverage that allows infrastructure changes with total security that the business logic remains intact.

📌Chapter 11: Project Architecture with FastAPI: Structure and Modularity

The difference between a script and an enterprise application lies in its organization. In this chapter, we analyze professional folder structures using the Clean Architecture pattern. We detail the separation of responsibilities: routers for endpoint definitions, services for pure business logic, and schemas for data contract definitions. This modularity allows the system to be scalable, enabling multiple teams to work on different API modules without version control conflicts, ensuring the code is testable and easy to navigate.

📌Chapter 12: Immutable Data Modeling with Pydantic V2

Information integrity is an organization's most valuable asset. Pydantic V2, rewritten in Rust, is not just a validation tool; it is a high-performance data analysis engine. In this chapter, we delve into creating complex models, using custom validators (@field_validator), and managing advanced data types such as UUIDs, email addresses, and URLs. You will learn how Pydantic's automatic type coercion eliminates the need for hundreds of lines of defensive code, guaranteeing that if data reaches the service layer, it strictly complies with the defined contract.

📌Chapter 13: Dependency Injection: Decoupling and Testability

FastAPI's Dependency Injection system is one of the most powerful in the Python ecosystem. This chapter explains how to use it to inject database sessions, authentication services, or external configurations hierarchically. This technique allows for total decoupling: your route logic does not need to know how to connect to the database, only that it receives a valid connection. This is fundamental for unit testing, as it allows swapping real dependencies for mocks or in-memory services with a single line of code, without modifying production logic.

📌Chapter 14: Advanced Parameter Management and Input Validation

A robust API must be strict with what it receives and generous with what it returns. We explore the exhaustive use of Path, Query, Body, and Header to capture and validate client information. Techniques for handling optional parameters, complex default values, and documentation metadata are detailed. You will learn to use FastAPI's capabilities to restrict inputs (such as minimum string lengths or numerical ranges) directly in the endpoint definition, which automatically generates clear error responses (422 Unprocessable Entity) without manual developer intervention.

📌Chapter 15: Object Serialization and Custom Responses

How an API delivers data is as important as how it receives it. This chapter addresses advanced serialization: transforming complex database models into optimized JSON responses. We analyze the use of response_model to filter sensitive data (such as password hashes), the creation of custom responses with different HTTP status codes, and the implementation of Streaming Responses to send large volumes of data or heavy files without saturating the server's RAM, optimizing the end-user experience.

📌Chapter 16: Asynchronous Database Connection with SQLAlchemy 2.0

Data access is traditionally the bottleneck of applications. SQLAlchemy 2.0 introduces a modern and fully asynchronous paradigm that aligns with the Python Event Loop. In this chapter, we break down the configuration of the asynchronous engine, the creation of declarative models, and session management via Asynchronous Context Managers. Emphasis is placed on using the select() syntax to perform powerful queries secure against SQL injections, ensuring that communication with the database engine (PostgreSQL or MySQL) does not block the execution of other concurrent requests.

📌Chapter 17: Schema Migrations with Alembic and Data Evolution

Databases in professional environments are never static. Alembic is the standard tool for managing schema evolution in a controlled and versioned manner. This chapter details how to generate automatic migrations by detecting changes in SQLAlchemy models, how to perform safe rollbacks in case of failure, and the importance of integrating migrations into the CI/CD deployment process. An architect must master Alembic to ensure that all environments (development, testing, and production) maintain a consistent data structure free of synchronization errors.

📌Chapter 18: Query Optimization and the N+1 Problem

Even the best Python code can fail if the database is slow. We analyze the N+1 Query Problem phenomenon, where one query triggers multiple unnecessary additional requests. This chapter teaches advanced relationship loading techniques: selectinload and joinedload. You will learn to perform efficient Joins and use query profiling to identify bottlenecks. Optimization at the data layer is what allows an application to go from handling a few hundred records to millions of rows without degrading response time.

📌Chapter 19: NoSQL Database Integration: MongoDB and Redis

Not all data belongs in a relational table. This chapter explores when and how to integrate NoSQL solutions into the Python backend. We analyze the use of Redis as an ultra-high-speed caching layer to reduce the load on the main database and manage user sessions. We also cover asynchronous integration with MongoDB (using Motor), ideal for flexible product catalogs or massive event logging systems. You will learn to decide the correct data architecture based on the read and write speed required by the business.

📌Chapter 20: Automated Documentation and OpenAPI Standards

One of the greatest advantages of developing with Python and FastAPI is the automatic generation of documentation. This chapter delves into OpenAPI and JSON Schema standards. We detail how to customize the Swagger UI and ReDoc interfaces, adding technical descriptions, response examples, and security schemes. Impeccable documentation is the calling card of a professional backend, allowing frontend teams and business partners to integrate the service without the need for constant meetings, accelerating the global development cycle.

📌Chapter 21: API Security Fundamentals and the OAuth2 Standard

Security is not an add-on; it is the foundation of digital trust. In this chapter, we analyze the OAuth2 protocol as the industry standard for authorization. You will learn how Python manages different access grants (flows), allowing third-party applications or modern frontends to interact with your backend without exposing user credentials. We detail the implementation of secure password flows and how to structure the permission hierarchy necessary to protect sensitive resources in a microservices environment.

📌Chapter 22: Implementation of JWT (JSON Web Tokens) and Stateless Auth

Stateless authentication is vital for scalability. In this chapter, we break down the structure of a JWT: the Header, the Payload, and the Signature. You will learn to use Python libraries such as python-jose or PyJWT to generate cryptographically signed tokens containing user identity. We analyze why this method allows your backend to scale horizontally infinitely, as the server does not need to store sessions in memory, delegating verification to the system's secret key.

📌Chapter 23: Applied Cryptography: Security Hashing and Passlib

Storing passwords in plain text is a critical act of negligence. This chapter delves into modern hashing algorithms such as Bcrypt and Argon2id. Using the passlib library, you will learn to implement automatic salting, which protects databases against rainbow table attacks. We detail the importance of expensive computation in hashing to mitigate brute-force attacks, ensuring that even if the database is compromised, user information remains inaccessible.

📌Chapter 24: Role-Based Access Control (RBAC) and Scopes

Not all users are equal. This chapter teaches how to design a granular permission system using OAuth2 Scopes and Python decorators. You will learn to restrict specific endpoints based on the user's role (Admin, Editor, Viewer) directly within FastAPI's dependency injection. This architecture allows for centralized permission management, facilitating security audits and ensuring each user has access strictly to what is necessary for their function (Principle of Least Privilege).

📌Chapter 25: Protection Against Web Attacks: CORS, XSS, and CSRF

A professional backend must resist hostile internet traffic. In this chapter, we configure security Middlewares to manage CORS (Cross-Origin Resource Sharing), preventing unauthorized sites from making requests to our API. We analyze input sanitization techniques to prevent script injection (XSS) and how using JWT tokens in Authorization headers helps mitigate CSRF (Cross-Site Request Forgery) attacks, shielding the server's network layer.

📌Chapter 26: Secure Management of Environment Variables and Secrets

API keys and database credentials must never be in the source code. This chapter addresses the use of python-dotenv and Pydantic Settings configuration models to manage settings externally. We detail the variable loading hierarchy and how to integrate professional Secrets Management systems (such as AWS Secrets Manager or Vault) to ensure sensitive information is encrypted at rest and only accessible by the Python execution process in production.

📌Chapter 27: Rate Limiting and Abuse Prevention

Availability is a form of security. This chapter teaches how to implement Rate Limiting using Redis and Python. You will learn to restrict the number of requests per second a user or IP address can make, protecting your infrastructure against DoS (Denial of Service) attacks and unauthorized massive scraping. This layer of protection is essential for maintaining system stability under stress or automated exploitation attempts.

📌Chapter 28: Auditing, Logging, and Request Traceability

When an incident occurs, visibility is the only tool for defense. This chapter details the configuration of a Structured Logging system in JSON format, ideal for ingestion into systems like ELK or Datadog. You will learn to implement Correlation IDs (X-Request-ID) that travel across all microservices, allowing you to trace the flow of a single suspicious request through your entire Python infrastructure, facilitating debugging and digital forensics.

📌Chapter 29: Transport Layer Security: SSL/TLS and HSTS

Interception of data in transit is a constant risk. In this chapter, we analyze how to secure communication through SSL/TLS certificates. Although SSL termination usually occurs at a reverse proxy (like Nginx), you will learn to configure your Python backend to force HTTPS usage through HSTS headers. Best practices for avoiding the transmission of sensitive information over unencrypted channels are explained, guaranteeing end-to-end data privacy.

📌Chapter 30: Dependency Auditing and Pipeline Security (CI)

Third-party code is an attack surface. This chapter closes the security block by teaching how to use tools like safety or bandit within Python. You will learn to automatically scan your dependencies for known vulnerabilities and perform Static Analysis to detect security weaknesses before each deployment. A professional system updates constantly and maintains a clear inventory of its libraries to mitigate supply chain attacks.

📌Chapter 31: Microservices Architecture Principles with Python

The transition toward microservices is not just a technical decision, but an organizational one. In this chapter, we analyze the Bounded Context pattern from Domain-Driven Design (DDD). You will learn to split a Python application into independent services that own their own database, avoiding tight coupling. The advantages of independent scalability are detailed, along with how to manage the complexity of a service network that must communicate efficiently and resiliently.

📌Chapter 32: Asynchronous Communication: RabbitMQ and the AMQP Protocol

In distributed systems, synchronous communication (HTTP) can create bottlenecks. This chapter introduces the use of RabbitMQ as a message broker. Using libraries like Aio-Pika, you will learn to implement the Publisher/Subscriber pattern. This allows a Python service to emit an event (such as "User Registered") and have multiple interested services (Email Delivery, Analytics, Billing) process it in the background without affecting the final user's response time.

📌Chapter 33: Background Task Processing with Celery and Redis

Heavy operations, such as PDF generation or image processing, should not execute within the lifecycle of an HTTP request. This chapter delves into Celery, the industry standard for task queues in Python. You will learn to configure independent Workers, manage automatic retries upon failure, and use Redis as a result backend. Emphasis is placed on the importance of monitoring these queues to avoid server resource saturation.

📌Chapter 34: Real-Time Communication with WebSockets and FastAPI

Certain applications require instant updates without the client having to refresh the page. This chapter details the implementation of the WebSockets protocol over ASGI. You will learn to manage persistent connections asynchronously, enabling the creation of chats, push notification systems, or live financial dashboards. Connection state management is analyzed, along with how to scale WebSockets using the Broadcasting mechanism with Redis Pub/Sub.

📌Chapter 35: Microservices Orchestration: Service Discovery and API Gateway

As services multiply, manual management of their IP addresses becomes impossible. This chapter addresses the concept of Service Discovery and the use of an API Gateway (such as Kong or Traefik). You will learn how to centralize authentication, routing, and load balancing at a single entry point, allowing your Python backend to be hidden behind a unified interface that simplifies consumption for external clients.

📌Chapter 36: Event-Driven Architecture (EDA) API Design

The event paradigm transforms how services interact. In this chapter, we explore how to design systems where state propagates through event streams. We analyze Eventual Consistency, accepting that data may take milliseconds to synchronize between microservices in exchange for extreme availability. Techniques for avoiding message loss and ensuring the system can recover from message broker failures are detailed.

📌Chapter 37: Resilience Patterns: Circuit Breaker and Retries with Tenacity

In a network, failures are inevitable. This chapter teaches how to implement the Circuit Breaker pattern using Python libraries to detect when an external service is down and temporarily stop sending requests, avoiding the "domino effect." We also go deep into the Tenacity library to manage intelligent retry strategies with exponential backoff and jitter, ensuring small network fluctuations do not interrupt the service for the user.

📌Chapter 38: Data Synchronization and Distributed Transactions (Saga Pattern)

One of the greatest challenges of microservices is maintaining the integrity of a transaction that affects multiple databases. This chapter introduces the Saga Pattern, a sequence of local transactions where each updates its own database and publishes an event. You will learn to manage compensating transactions (undoing changes) in case an intermediate step fails, guaranteeing system consistency without resorting to costly distributed locks.

📌Chapter 39: Observability and Distributed Tracing with OpenTelemetry

Understanding what happens inside a microservices network requires specialized tools. This chapter details the integration of OpenTelemetry into Python applications. You will learn to generate Traces that allow you to visualize the path of a request from the moment it enters the Gateway until it hits the last database of a remote microservice. This is vital for identifying latency bottlenecks and errors occurring in inter-service communication.

📌Chapter 40: Professional Containerization with Docker for Microservices

For this ecosystem to function, each microservice must be portable and isolatable. This chapter closes the block with the advanced use of Docker. You will learn to write multi-stage Dockerfiles to optimize the size of Python images, manage internal networks between containers, and use Docker Compose to spin up a complete development environment including the API, databases, and message brokers with a single command.

📌Chapter 41: Production Image Optimization (Multi-stage Builds)

In production environments, Docker image size and security are critical. This chapter delves into the creation of Multi-stage builds for Python, where we use a robust image to compile dependencies and a lightweight image (such as Alpine or Distroless) for final execution. This reduces the attack surface by eliminating unnecessary compilation tools in the production container and accelerates deployment times by minimizing the weight of software layers.

📌Chapter 42: Orchestration with Kubernetes: From Container to Cluster

When infrastructure grows beyond a few containers, Kubernetes (K8s) becomes indispensable. In this chapter, we analyze the anatomy of a professional deployment: Pods, Deployments, and Services. You will learn to configure Liveness and Readiness Probes so the cluster knows when a Python microservice is ready to receive traffic or when it must be automatically restarted due to an internal failure.

📌Chapter 43: Continuous Integration and Deployment (CI/CD) with GitHub Actions

Automation is the pillar of agility. This chapter details the creation of CI/CD pipelines that automatically execute the Pytest suite, verify typing with Mypy, and build the Docker image on every push. You will learn to configure secure deployment strategies, such as Blue-Green or Canary Deployments, ensuring that code updates reach users without service interruptions.

📌Chapter 44: Proactive Monitoring with Prometheus and Grafana

You cannot improve what you cannot measure. This chapter teaches how to expose custom metrics from your Python application (such as response time per endpoint or number of failed transactions) using the Prometheus format. You will learn to design dashboards in Grafana that provide real-time visualization of your backend's health, allowing you to identify anomalies before they affect the user experience.

📌Chapter 45: Centralized Log Management (ELK Stack)

In a microservices architecture, searching for errors in local text files is inefficient. This chapter addresses the implementation of the ELK stack (Elasticsearch, Logstash, Kibana). You will learn to structure your logs in JSON format so they are easily indexable and searchable. Emphasis is placed on the importance of audit logs to track critical user actions and diagnose complex problems occurring in the interaction between multiple services.

📌Chapter 46: Cloud Deployment: AWS Lambda and ECS (Fargate)

The modern backend is often hybrid or "serverless." In this chapter, we explore deployment options on Amazon Web Services (AWS). We analyze when to use AWS Lambda for event-driven tasks and when to opt for ECS (Elastic Container Service) with Fargate for persistent Python services. You will learn to manage Infrastructure as Code (IaC) and configure Application Load Balancers (ALB) to handle traffic on a global scale.

📌Chapter 47: Static Code Analysis and Dependency Security

Security is a continuous process. This chapter focuses on the use of Static Application Security Testing (SAST) tools like Bandit to detect common vulnerabilities in Python code (such as injections or the use of insecure libraries). We also detail the integration of dependency scanning tools to ensure that no third-party library introduces backdoors or known flaws into your professional ecosystem.

📌Chapter 48: Horizontal Scaling Strategies and Load Balancing

A high-performance system must respond elastically to demand. We analyze Load Balancing algorithms and how to configure auto-scaling based on CPU metrics or latency. This chapter teaches how to design stateless applications in Python, allowing you to dynamically spin up or down dozens of service instances according to traffic volume, optimizing infrastructure operating costs.

📌Chapter 49: Benchmarking, Profiling, and Bottleneck Optimization

Before closing, it is vital to identify the slow parts of the code. This chapter introduces advanced Profiling using tools like cProfile and py-spy. You will learn to interpret Flame Graphs to visualize where the processor spends the most time and how to apply specific optimizations (such as using __slots__ in classes or delegating tasks to C extensions) to gain critical milliseconds on the most traveled routes.

📌Chapter 50: The Future of Python: Performance and Language Evolution

We close the treatise by analyzing future trends. From performance improvements in CPython (such as the Faster CPython project) to the impact of WebAssembly (Wasm) and the development of JIT compilers. This chapter prepares the professional to stay at the forefront, understanding that Python continues to evolve to offer the simplicity we love with the speed that tomorrow's systems demand.

❓Final Q&A Section

📎Is Kubernetes necessary for all Python projects?

No. For small or medium projects, Docker Compose or services like AWS App Runner are sufficient. Kubernetes is justified when managing a fleet of microservices that require self-healing and complex, massive scalability.

📎What is the most important thing when monitoring a professional backend?

The most important thing is to define clear SLAs (Service Level Agreements). You should monitor 5XX errors, P95 latency (95th percentile), and database saturation. If these three are under control, your service is usually healthy.

📎How can I reduce my cloud infrastructure costs?

The key is auto-scaling and resource optimization. Do not pay for powerful servers that are idle 80% of the time. Use smaller instances and scale horizontally only when strictly necessary.