liveBookmanning.com

What you will learn in Rust Servers, Services, and Apps

by Prabhu E

Read it on liveBook Get the book at manning.com

Chapter by chapter

Concepts explained in this book

• routingA router is a request-dispatching component that selects a handler based on the characteristics of an incoming request.
• multithreadingMultithreading is a technique for executing multiple threads of control within a process, potentially in parallel or through interleaving.
• request messagePOST is an HTTP method that submits data for processing by a target resource.
• async runtimeAn asynchronous runtime is software that schedules and executes nonblocking asynchronous operations and tasks.
• web applicationA web application is software that provides interactive services through web interfaces and network communication.
• Actix WebActix Web is a Rust web framework for building HTTP servers and web applications.
• stateApplication state is the data representing the current condition of an application's configuration, behavior, or resources.
• RustRust is a statically typed systems programming language designed for memory safety, concurrency, and low-level control without a garbage collector.
• From traitFrom is the Rust standard-library trait for defining infallible conversions from one type into another.
• non-blocking I/ONon-blocking I/O allows computation to continue without waiting synchronously for an input or output operation to complete.
• containerAn execution environment in which an application runs inside an isolated, portable software container.
• taskAn asynchronous task is a schedulable unit of asynchronous computation managed by an asynchronous runtime.
• RESTREST is an architectural style for networked applications that models functionality as interactions with identifiable resources.
• asynchronous programmingAsynchronous programming is a technique in which tasks can suspend during external operations and allow other tasks to make progress before resuming.
• async/awaitAn async function is a function whose execution can suspend while awaiting asynchronous operations and later resume.
• container imageA Docker image is an immutable package containing a filesystem, metadata, and application dependencies from which containers can be created.
• ResponseErrorResponseError is an Actix Web trait that defines how an application error is converted into an HTTP response and status code.
• concurrencyConcurrent programming is the design of programs whose multiple operations can make progress during overlapping periods of time.
• question mark operatorThe Rust question-mark operator unwraps successful results or propagates errors or absence from the enclosing function.
• futureThe Rust Future trait defines the interface for an asynchronous computation that can be polled toward completion.
• web serviceA web service is a software service that exposes functionality for network clients through web communication protocols.
• executorThe Tokio executor is the Tokio runtime component that drives futures toward completion by polling them when they can make progress.
• Docker ComposeDocker Compose is a tool for defining and operating multi-container applications from a declarative configuration.
• HTTP responseHttpResponse is a Rust structure representing an HTTP response message with status information, headers, and an optional body.
• error typeA custom error type is a programmer-defined Rust type that represents application-specific failures and can unify multiple underlying error types.
• credentialUser credentials are authentication information, such as a username and password, used to authenticate a user.
• serverA web server is software that accepts network requests and returns responses, typically over HTTP.
• TeraA Tera template is a markup or text document containing Tera syntax for substituting data and controlling generated output.
• web formA web form is a user-interface mechanism for collecting and submitting structured input through a web page.
• database tableA database table is a structured relational-data object consisting of rows organized under defined columns and constraints.
• pollPoll is a Rust result type that indicates whether a polled asynchronous computation is ready with a value or still pending.
• data modelA data model is a structured specification of the data entities, fields, and relationships represented by a software system.
• FromRowFromRow is an SQLx trait for constructing a Rust value from a database query result row.
• TCPTransmission Control Protocol is a connection-oriented transport protocol that provides reliable, ordered delivery of a byte stream between endpoints.
• type safetyType safety is the property that program operations respect the constraints of their declared or inferred types.
• SQLxSQLx is a Rust library for asynchronous, compile-time checked interaction with SQL databases.
• threadA thread is an independently schedulable sequence of instructions within a process that can execute concurrently with other threads.
• blockingA blocking operation is an operation that prevents its executing thread or task from continuing until an external activity completes.
• synchronous callSynchronous programming executes an operation and waits for it to complete before continuing with subsequent work.
• query_as! macroquery_as! is an SQLx compile-time macro that maps SQL query results into a specified Rust type and checks the query against the database schema.
• unwrapunwrap is a Rust method that extracts a value from an Option or Result and panics if it is None or Err.
• unit testA unit test is an automated test that checks the behavior of a small, isolated program component.
• meanLatency is the delay between an operation being initiated and its observable completion or response.
• memory safetyMemory safety is the property that a program cannot perform invalid accesses, use deallocated values, or otherwise violate memory-access rules.
• thread safetyThread safety is the property that shared program behavior remains correct when accessed concurrently by multiple threads.
• Docker networkA Docker network is a Docker-managed virtual network that enables communication between containers and other network endpoints.
• Docker volumeA Docker volume is Docker-managed persistent storage whose contents exist independently of a container's lifecycle.
• DockerfileA Dockerfile is a text configuration file containing instructions for building a Docker image.
• compute-boundA CPU-bound program is a program whose progress rate is primarily limited by processor computation speed.
• I/O-bound workAn I/O-bound program is a program whose progress rate is primarily limited by the speed of input and output operations.
• workspaceA Cargo workspace is a set of related Rust packages managed and built together by Cargo.
• testTesting is the systematic evaluation of software behavior against expected results under specified scenarios.
• WakerA Rust Waker is a handle that allows an asynchronous computation to notify its executor that it should be polled again.
• garbage collectionGarbage collection is automatic reclamation of memory occupied by objects that are no longer reachable by a program.
• cargo.tomlCargo.toml is a manifest file that declares a Rust package's metadata, dependencies, targets, and related Cargo configuration.
• result typeA Result is a Rust standard-library generic type representing either successful output or an error.
• PostgreSQLPostgres is an open-source object-relational database management system.
• request extractorA request extractor is an Actix Web component that obtains typed request or application data for a handler.
• borrow checkerThe borrow checker is the Rust compiler component that statically verifies ownership, borrowing, and reference-lifetime rules.
• borrowingBorrowing is Rust's mechanism for granting temporary access to a value without transferring its ownership.
• data raceA data race is an unsynchronized concurrent access to shared data in which at least one access mutates the data.
• default immutabilityDefault immutability is a language rule requiring explicit declaration before a variable can be mutated.
• safetyThe property of software or a programming language preventing classes of invalid or hazardous behavior.
• ownershipAn ownership model assigns each value a responsible owner and determines when that value may be accessed or destroyed.
• static typingStatic typing determines and checks program types before execution, generally during compilation.
• server-side renderingServer-side rendering is a web application pattern in which a server generates a fully rendered web page and sends it to a browser.
• moduleThe Rust module system organizes code into named modules that provide separation and visibility boundaries.
• parallelismParallelism is the simultaneous execution of multiple computations, typically on separate processors or cores.
• TokioTokio is a Rust asynchronous runtime and library for building network applications with nonblocking I/O.
• template engineA template engine is a software component that combines templates with data to generate rendered output such as HTML.
• JSON extractorA JSON extractor is an Actix Web request extractor that deserializes an HTTP request body into a typed Rust value.
• path extractorA path extractor is an Actix Web request extractor that reads typed values from URL path parameters.
• optionOption is a Rust standard-library generic type representing either a value or its absence.
• TCP clientA TCP client is a network participant that establishes a connection to a TCP server and exchanges byte-stream data.
• containerizationContainerization packages an application and its dependencies into isolated, portable runtime units called containers.
• distributed systemA distributed system is a collection of independent computing components that coordinate over a network to provide combined functionality.
• Actix ErrorActix Error is Actix Web's general-purpose error type for representing handler and application failures.
• ignore annotationThe Rust ignore annotation marks a test so that the test executor skips it during ordinary test-suite execution.
• HTTPThe Hypertext Transfer Protocol is an application-layer protocol for transferring resources and messages over networks.
• serializationSerialization is the conversion of an in-memory data structure into a structured representation suitable for transmission or storage.
• appAn Actix Web application object groups route configuration and processes incoming web requests.
• TCP/IP protocol suiteThe Internet Protocol suite is the four-layered family of networking protocols comprising the network access, Internet, transport, and application layers.
• static fileA static asset is a file served to clients without per-request content generation, such as a stylesheet or image.
• contractAn API is a defined interface through which software components communicate and request functionality or data.
• responseAn HTTP response message is the protocol-formatted message a server sends to an HTTP client in response to a request.
• lifetimeA Rust annotation and analysis concept describing how long references are valid.
• CargoCargo is Rust's build system and package manager for creating, compiling, testing, and managing Rust projects and dependencies.
• libp2plibp2p is a modular networking library that provides protocols and components for building peer-to-peer applications.
• HTTP GETGET is an HTTP request method for retrieving a representation of a resource.
• writeWrite is the Rust standard-library trait for byte-oriented output to a sink.
• connection poolingA connection pool is a managed collection of reusable database connections shared among clients or execution threads.
• tcp serverA TCP server is a network service that listens for and accepts connections using Transmission Control Protocol.
• authenticationAuthentication is the process of verifying the identity of a client or user before granting access to protected functionality.
• dynamic contentA dynamic web page is a web document whose content is generated or changed in response to request data, application state, or other runtime inputs.
• pinPin is a Rust standard-library pointer type that prevents a referenced value from being moved, preserving memory-location guarantees required by some asynchronous state machines.
• reactorA reactor is an asynchronous-runtime component that observes operating-system I/O events and communicates readiness to the runtime.
• routing configurationA route configuration is a declaration that associates a URL path and request pattern with a handler or service operation.
• peerA peer node is a participating device or software process in a peer-to-peer network that can communicate directly with other peers and provide or request services.
• error propagationError propagation is the technique of passing an operation's failure result to a caller so that a higher-level component can handle it.
• panicA panic is Rust's unrecoverable program-failure mechanism that unwinds or aborts execution when a runtime condition cannot be handled.
• SQL scriptA SQL script is a stored sequence of SQL statements intended for execution against a database.
• dependency injectionDependency injection is a technique in which a component receives the resources or services it needs from an external provider.
• peer-to-peer networkA peer-to-peer network is a distributed network in which nodes communicate and provide services directly without requiring a central coordinator.
• multiaddressA multiaddress is a self-describing network address format that can encode the protocols and endpoint information needed to reach a network node.
• Argon2argon2 is a password-hashing library implementing the Argon2 key-derivation algorithm.
• awcawc is an asynchronous HTTP client library for Rust in the Actix Web ecosystem.
• browser validationIn-browser validation is client-side checking of form input performed by a web browser before submission.
• password hashingPassword hashing is the one-way transformation of a password into a value intended for secure storage and later verification.
• distributed web applicationA distributed web service is a web service implemented by cooperating components deployed across multiple servers or locations.
• multistage buildA multistage Docker build uses multiple Dockerfile stages so that only selected artifacts from earlier stages are included in the final image.
• foreign keyA foreign-key constraint is a database rule requiring values in one table's column to reference valid values in another table's key column.
• directory structureA project structure is the organization of a software project's files, directories, modules, and related artifacts.
• ErrorThe Error trait is a Rust standard-library trait for types that represent and describe errors.
• match statementA match statement is a Rust control-flow construct that selects behavior by matching a value against patterns.
• return-value error handlingReturn-value error handling is an error-handling approach in which operations report success or failure through their returned values.
• static siteA static web page is a web document served as stored content rather than generated dynamically for each request.
• http request parsingHTTP request parsing is the process of interpreting an HTTP request representation and extracting its method, path, version, headers, and body.
• database operationDatabase access is the set of operations by which application code communicates with a database to store or retrieve data.
• PeerIdA peer ID is a unique cryptographic identifier assigned to a node in a peer-to-peer network.
• deserialize traitDeserialize is a deserialization trait that constructs values from an external data representation.
• not-null constraintA NOT NULL constraint requires every row in a database column to contain a non-null value.
• in-memory databaseAn in-memory data store is a data-storage component that keeps its working data in main memory rather than relying primarily on persistent storage.
• JSONJSON is a text-based data-interchange format that represents structured values using objects, arrays, strings, numbers, booleans, and null.
• service layerThe highest layer of the Internet Protocol suite, providing protocols for application-level network communication.
• payloadAn HTTP message body is the optional content payload carried after an HTTP message's headers.
• race conditionA race condition is a concurrency defect in which the result depends on the timing or interleaving of operations.
• databaseDatabase persistence is the storage of application data in a database so that it survives process termination and can be retrieved later.
• multicontainer configurationA multicontainer configuration is a declarative specification for building and running an application composed of multiple containers.
• database connectivityDatabase connectivity is the ability of an application to establish communication with and exchange operations with a database.
• SQLSQL is a declarative language for defining, querying, modifying, and controlling data in relational databases.
• database access logicA database access function is a program function that retrieves or modifies persistent data through a database interface.
• read traitThe Rust standard-library Read trait defines byte-reading behavior for types that provide input from a source.
• client-server architectureThe client-server model is a computing architecture in which clients request data or computation from dedicated servers that manage resources.
• backendA backend service is a server-side application component that implements application functionality and exposes it to clients or other services.
• derivable traitA derivable trait is a Rust trait implementation that the compiler can generate from a derive annotation.
• CSSCSS is a stylesheet language for specifying the presentation and visual styling of structured documents such as HTML.
• transport layerThe transport layer provides communication between endpoints and transfers application data as a stream or sequence of transport-level units.
• container runtimeA container runtime is software that creates and runs application containers from container images.
• mod.rsmod.rs is a Rust source-file convention for declaring the contents and child modules of a directory-based module.
• module organizationModule organization is the arrangement of Rust modules and their source files together with the paths used to declare and import them.
• refactoringCode refactoring is the restructuring of existing source code without changing its externally observable behavior.
• promiseA JavaScript promise is an object representing the eventual completion or rejection of an asynchronous operation and its resulting value.
• route parameterA URL path parameter is a variable value embedded in a URL path and supplied to the operation selected by that route.
• wake methodThe wake method on a Rust Waker notifies an asynchronous executor that the associated task should be scheduled for polling.
• traitA trait is a Rust abstraction that defines shared behavior or type constraints independently of a concrete type.
• TryFromTryFrom is a Rust standard-library trait for conversions that may fail and therefore return a result.
• invalid jsonInvalid JSON is input text that does not conform to the JSON syntax required for parsing.
• peer routingPeer routing is a technique in which nodes forward messages toward destination peers through other nodes in a peer-to-peer network.
• password hashA password hash is a derived representation of a password intended to support verification without storing the original password.
• relational database management systemA relational database is a database that organizes data into related tables with defined schemas and relationships.
• DockerDocker is a platform and toolset for building, packaging, and running applications in containers.
• CRUDCRUD is the set of create, read, update, and delete operations commonly provided for a resource.
• network access layerThe network access layer is the lowest layer of the TCP/IP model, responsible for transmitting data over physical links between hosts.
• join!The Rust join macro drives multiple asynchronous computations and completes after all of them complete.
• database scriptA database script is a file containing commands for creating, modifying, or otherwise administering database objects and data.
• ResponderResponder is an Actix Web trait whose implementations can produce HTTP responses.
• application frontendA user-facing application component, such as a mobile or browser-based interface, that communicates with remote backend services.
• pending statePoll::Pending is a Rust polling result indicating that an asynchronous computation is not yet ready to produce its output.
• readyPoll::Ready is a Rust polling result indicating that an asynchronous computation has produced its output.
• client-side validationClient-side validation is validation of submitted data performed in the user's browser before a request is processed by a server.
• separation of concernsSeparation of responsibilities is a design principle that assigns distinct concerns to different software components.
• server validationServer-side validation is validation of request data performed by a server before the requested operation is completed.
• private keyA private key is the secret member of a cryptographic key pair used to authenticate its holder or perform private-key cryptographic operations.
• validationInput validation is the process of checking supplied data against format, length, type, or business constraints before processing it.
• network layerThe network layer routes packets between hosts across networks using network addresses and routing mechanisms.
• networking modelA networking model is an abstract framework that describes how messages are communicated between senders and receivers across a network.
• HTTP clientAn HTTP client is software that constructs and sends HTTP requests and processes the resulting HTTP responses.
• serde_jsonserde_json is a Rust library that provides JSON serialization and deserialization through Serde.
• network stackA layered collection of networking protocols and supporting implementations that enables communication between distributed system components.

These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.