GratisFullStackintermediate

Microservices With Spring Boot

Name: Microservices With Spring Boot
Availability: InStock

Build and deploy production-ready Java microservices with Spring Boot, REST APIs, databases, testing, Docker, Kubernetes, and AWS.

4 semanasEN118 licoes1,156 inscritos

Curado do YouTube

Este curso foi selecionado a dedo do YouTube por nossos especialistas e organizado em um currículo estruturado passo a passo.

Iniciarcursogratis

Conteudo do curso

10 modulos · 60 assuntos · 118 licoes

Git and GitHub EssentialsLearn the fundamentals of Git and GitHub, from setting up your environment and tracking changes to branching, merging, remote repositories, and working with GitHub.

3 assuntos

Git FundamentalsLearn what Git is, set up your development environment, and start tracking changes in a project.

1 licoes

Getting Started with GitUnderstand Git and GitHub, configure your environment, and learn the basic Git workflow.

Git History and BranchingLearn how to manage project history, undo changes, and develop different versions of a project using branches.

2 licoes

Managing Changes and HistoryWork with Git history and learn how to return a project to an earlier commit.
Branching and MergingUse branches to work on changes independently and merge completed work back into a project.

Git and GitHub WorkflowConnect local Git repositories to GitHub and learn how local development and remote repositories work together.

2 licoes

Connecting Git to GitHubConnect a local Git repository to GitHub and begin working with a remote repository.
Working with Git and GitHubCombine local Git workflows with GitHub to manage and share project changes.

Java ProgrammingA practical Core Java course that takes you from writing your first Java program to building structured applications with object-oriented programming, arrays, collections, exceptions, files, dates, generics, and concurrency. Along the way, you will reinforce concepts through small programs and projects such as calculators, games, banking systems, and utility applications.

10 assuntos

Java FundamentalsLearn the basic Java syntax and programming concepts needed to start writing useful programs.

4 licoes

Getting Started with JavaSet up Java and learn the basic building blocks of a Java program.
Operators and CalculationsPerform calculations and produce formatted numerical output.
Working with StringsManipulate and extract information from text using Java strings.
Type Conversion and Conditional ExpressionsConvert values between units and use concise conditional expressions.

Control Flow and Decision MakingControl how Java programs make decisions, repeat operations, and respond to different conditions.

3 licoes

Conditional LogicUse if statements, nested conditions, logical operators, and switch expressions.
Loops and RepetitionRepeat operations with while loops, for loops, nested loops, and loop-control statements.
Random Values and Small ApplicationsUse random values and control flow to build simple interactive programs.

Methods and ArraysOrganize Java code into reusable methods and work with collections of values using arrays.

2 licoes

Methods and Reusable LogicCreate reusable methods and understand parameters, overloading, scope, and variable arguments.
ArraysStore, search, and process multiple values using Java arrays.

Object-Oriented ProgrammingLearn the core object-oriented concepts used to design structured Java applications.

4 licoes

Classes, Objects, and ConstructorsCreate Java classes and objects and initialize them with constructors.
Static Members and EncapsulationControl class-level data and protect object state through encapsulation.
Inheritance and PolymorphismReuse behavior through inheritance and create flexible object-oriented designs with polymorphism.
Abstraction and InterfacesSeparate implementation details from contracts using abstraction and interfaces.

Java Data Structures and Utility TypesWork with wrapper types, dynamic collections, generic types, maps, and enums.

2 licoes

Wrapper Classes and ArrayListsWork with object representations of primitive values and dynamically sized lists.
Generics, HashMaps, and EnumsMake collections type-safe and represent structured key-value data and fixed sets of values.

Exceptions and File HandlingHandle runtime problems and persist application data through file operations.

2 licoes

Exception HandlingHandle exceptional situations without allowing applications to fail unexpectedly.
Reading and Writing FilesPersist information by writing data to files and reading it back into Java applications.

Java Projects and Application UtilitiesApply Core Java concepts to larger console projects and useful application utilities.

1 licoes

Interactive Java ProjectsCombine Java fundamentals and object-oriented concepts to build complete interactive programs.

Dates, Time, and Scheduled TasksWork with dates and times and build applications that execute tasks around time-based events.

2 licoes

Java Dates and TimesRepresent and work with dates and times in Java applications.
Timers and Scheduled TasksSchedule Java tasks and build time-based utilities.

Java Concurrency and MultithreadingUnderstand threads and use multiple threads to perform work concurrently.

1 licoes

Threads and MultithreadingLearn the fundamentals of Java threads and how applications can execute multiple tasks concurrently.

Student Management SystemApply the Core Java concepts from the course to plan, build, and deliver a complete Java application that manages students, instructors, and courses.

1 licoes

Capstone ProjectPlan, implement, and deliver a Java application that manages students, instructors, and courses, applying object-oriented design, collections, exceptions, files, and the utilities covered in the course.

Build an HTTP Server from Scratch with JavaLearn how HTTP works by building a simple HTTP server in Java from the ground up, starting with TCP server sockets and progressing through request parsing, HTTP methods, status codes, headers, concurrency, and serving files.

4 assuntos

HTTP Server Foundations and Java SetupSet up the Java environment and build the mental model of how a socket becomes an HTTP server.

1 licoes

Course Setup and Server ArchitectureGet the Java project ready and map out the architecture that turns a network socket into an HTTP server.

TCP Connections and Concurrent ClientsCreate a server socket and extend it to handle many clients simultaneously with threads.

2 licoes

Server Sockets and Client ConnectionsListen for incoming network connections with a server socket and establish communication with clients.
Handling Multiple ConnectionsProcess independent client connections concurrently using Java threads.

Understanding and Parsing HTTP RequestsParse raw HTTP messages into structured requests: request line, methods, status codes, and headers.

3 licoes

HTTP Message Structure and Request ParsingRead the raw bytes arriving through a socket and parse them into an HTTP request the server can understand.
HTTP Methods and Request-Line ProcessingParse the request line precisely and work with the HTTP methods clients use to describe operations.
HTTP Request HeadersParse the header lines that carry metadata alongside every HTTP request.

Serving Files and Completing the HTTP ServerServe real files to clients and complete a working HTTP server.

1 licoes

Handling and Serving FilesMap incoming requests to files on disk and return them to clients as complete HTTP responses.

SQL Fundamentals to AdvancedLearn SQL from the ground up, progressing from database setup and basic queries to joins, aggregations, data modification, window functions, CTEs, temporary tables, stored procedures, and subqueries.

3 assuntos

SQL FoundationsNew Description

2 licoes

Getting Started with SQLSet up a SQL development environment, create tables, and learn the basic structure of SQL queries.
Filtering and Organizing Query ResultsLearn how to narrow query results and organize returned data using filtering, grouping, and sorting.

Intermediate SQL QueriesExpand your querying skills by combining tables, creating conditional results, and working with more advanced filtering and aggregation techniques.

3 licoes

Joins and Combining ResultsLearn how SQL combines related data from multiple tables using joins and union operations.
Conditional Logic and AggregationUse CASE and HAVING to build conditional query results and filter grouped data after aggregation.
Updating and Naming Query DataModify existing database records and improve query readability using aliases.

Advanced SQL QueryingWork with window functions, common table expressions, temporary tables, string functions, stored procedures, and subqueries.

4 licoes

Window Functions and Data AnalysisUse PARTITION BY to perform calculations across related groups of rows without collapsing the underlying result set.
Common Table Expressions and Temporary TablesBreak complex SQL work into manageable intermediate result sets using CTEs and temporary tables.
String Functions and Stored ProceduresManipulate text data with SQL string functions and encapsulate reusable database logic with stored procedures.
SubqueriesUse queries inside other queries to solve problems that require intermediate or dependent result sets.

Design Relational Databases from ScratchLearn how to design relational databases by modeling entities, defining relationships, avoiding common schema mistakes, handling flexible data, and applying database design principles to real-world systems.

4 assuntos

Database Design FoundationsLearn the process of turning real-world requirements into a structured relational database and recognize the decisions that shape a good schema.

4 licoes

Designing a DatabaseLearn a systematic approach to identifying data, defining entities, and translating application requirements into a relational database structure.
One-to-Many RelationshipsLearn how to identify, model, and implement one-to-many relationships between database entities.
Many-to-Many RelationshipsLearn how to model many-to-many relationships using an intermediate table.
Common Database Design MistakesIdentify common schema design problems and understand how to correct them before they become difficult to maintain.

Advanced Relational ModelingHandle more complex modeling problems involving flexible attributes, hierarchical data, and entities that do not fit simple table structures.

3 licoes

Self-Referencing RelationshipsLearn how an entity can reference other records of the same entity to model hierarchical or related data.
Custom FieldsExplore database structures for storing user-defined or application-specific fields without constantly changing the core schema.
Product AttributesApply flexible database modeling to products whose attributes can vary across different product types.

SQL Joins and Relational QueriesLearn how relationships represented in a database schema are used to retrieve related data across multiple tables.

3 licoes

SQL JoinsLearn the purpose of SQL joins and how they combine related records from multiple tables.
Joining Multiple TablesExtend relational queries to combine information from three or more related tables.
Self JoinsUse self joins to query hierarchical or self-referencing data stored within a single table.

Database Design in PracticeApply database design principles to realistic applications and learn how different requirements lead to different relational models.

1 licoes

Application Database Case StudiesStudy complete database designs for familiar applications and identify how their requirements translate into entities and relationships.

Microservices with Spring Boot and Spring CloudA practical course for building a production-oriented Spring Boot microservices system from the ground up. Start by creating independent services and connecting them with REST and OpenFeign, then add service discovery, gateways, security, resilience, event-driven communication, API documentation, observability, containerization, and Kubernetes deployment.

9 assuntos

Microservices FoundationsBuild the core services and understand how a Spring Boot microservices architecture is structured.

2 licoes

Building MicroservicesCreate independent Spring Boot services and establish the foundation for a distributed application.
Service-Specific DevelopmentExpand the system by implementing concrete business services and their responsibilities.

Service Communication and DiscoveryConnect microservices and introduce service discovery so services can locate one another dynamically.

2 licoes

Inter-Service CommunicationEnable services to communicate with one another through REST-based calls.
Service DiscoveryIntroduce service discovery so microservices can find one another without relying entirely on fixed service locations.

API Gateway and External AccessCreate a gateway layer that provides a controlled entry point into the microservices system.

1 licoes

API GatewayRoute external requests through a centralized gateway and control how clients access backend services.

Security and API DocumentationSecure microservices with Keycloak and document their REST APIs with OpenAPI.

2 licoes

Microservices SecurityIntroduce authentication and authorization across the microservices architecture.
REST API DocumentationDocument microservice APIs so their endpoints and contracts are easier to understand and consume.

Resilience and Distributed SystemsMake the microservices architecture more resilient to failures and unavailable dependencies.

1 licoes

Circuit Breakers with Resilience4JProtect service calls from cascading failures using circuit breaker patterns.

Event-Driven Microservices with KafkaIntroduce asynchronous communication and event-driven architecture using Apache Kafka.

1 licoes

Kafka and Event-Driven ArchitectureMove beyond synchronous service calls by exchanging events through Kafka.

Observability and Distributed TracingMonitor, trace, and understand behavior across distributed Spring Boot services.

2 licoes

Distributed TracingTrace requests as they move across multiple microservices.
Grafana Stack ObservabilityBuild a broader observability setup around the Spring Boot microservices application.

Frontend IntegrationConnect a frontend application to the Spring Boot microservices architecture.

1 licoes

Angular Application IntegrationSet up a frontend application that interacts with the microservices backend.

Containerization and DeploymentPackage the microservices application into containers and deploy the system to Kubernetes.

2 licoes

Dockerizing Spring Boot MicroservicesPackage the microservices application and its components into Docker containers.
Kubernetes DeploymentDeploy the containerized microservices system to Kubernetes.

Build REST APIs and Microservices with Spring BootLearn how to build REST APIs with Spring Boot and evolve them into production-oriented microservices using databases, service communication, configuration management, messaging, containers, Kubernetes, security, and cloud deployment.

13 assuntos

Spring Boot REST API FoundationsNew Description

2 licoes

Building CRUD REST APIsCreate a Spring Boot REST API for managing application data and implement the core CRUD operations.
Spring Boot MonitoringIntroduce Spring Boot Actuator for exposing application information and monitoring endpoints.

Database Persistence with Spring BootMove the REST API from temporary application data to persistent relational databases using Spring Data JPA, H2, and PostgreSQL.

2 licoes

Spring Data JPA and H2Introduce database persistence with Spring Data JPA and use H2 while developing the REST API.
PostgreSQL PersistenceReplace the development H2 database with PostgreSQL and configure the application to work with a more production-oriented database.

Introduction to MicroservicesUnderstand the transition from a monolithic Spring Boot application to independently deployable microservices.

1 licoes

Microservice ArchitectureUnderstand the motivation for microservices and begin decomposing the job application into individual services.

Microservice Communication and Service DiscoveryConnect Spring Boot microservices and introduce service discovery and declarative HTTP clients for communication between services.

1 licoes

Inter-Service CommunicationEnable microservices to communicate with each other through HTTP-based service calls.

Distributed Configuration and ResilienceAdd centralized configuration, distributed tracing, API gateway routing, and fault tolerance to the microservice system.

2 licoes

Observability and ConfigurationIntroduce distributed tracing and centralized configuration for a multi-service Spring Boot application.
API Gateway and Fault ToleranceIntroduce an API gateway and circuit breaking to make the microservice architecture more resilient.

Asynchronous Communication and PackagingIntroduce message-based communication and prepare Spring Boot microservices for containerized deployment.

2 licoes

Message QueuesIntroduce RabbitMQ for asynchronous communication between application components and services.
Packaging Spring Boot MicroservicesPackage Spring Boot microservices as executable JAR files for deployment.

Docker and Kubernetes for Spring BootContainerize the Spring Boot microservices and deploy the distributed application using Docker and Kubernetes.

1 licoes

Containerizing Spring Boot MicroservicesPackage the Spring Boot services into Docker containers and prepare their supporting infrastructure for deployment.

Spring Boot Microservices ProjectApply the architecture, Docker, Kubernetes, and AWS concepts in a broader Spring Boot microservices project.

1 licoes

Microservices Project from MonolithWork through a broader Spring Boot project that converts a monolith into microservices with Docker, Kubernetes, and AWS.

Spring Boot Configuration and SecretsManage configuration across Spring Boot applications and microservices while addressing profiles, cloud configuration, and secure secrets.

1 licoes

Configuration ManagementLearn how Spring Boot configuration can be organized across environments and centralized for distributed applications.

Event-Driven Communication with KafkaIntroduce Apache Kafka and Spring Cloud Streams for asynchronous, event-driven communication in Spring Boot applications.

1 licoes

Apache Kafka with Spring BootBuild an asynchronous communication flow using Kafka and Spring Boot.

Spring Boot Security and AuthenticationSecure Spring Boot applications using Keycloak, OAuth2, and authentication flows across a full-stack microservice environment.

1 licoes

Keycloak and OAuth2Introduce centralized authentication with Keycloak and OAuth2 in a Spring Boot application.

Spring Boot Deployment and CI/CDPrepare Spring Boot applications for cloud deployment and automate deployment using AWS and GitHub Actions.

2 licoes

AWS DeploymentDeploy a Spring Boot application to AWS and automate the deployment workflow with GitHub Actions.
Docker Containerization TechniquesExplore practical approaches for containerizing Spring Boot applications using Docker build tools.

Full-Stack Spring Boot ProjectBring Spring Boot, microservices, cloud infrastructure, security, and a React frontend together in a larger application project.

1 licoes

Spring Boot AI Microservice ApplicationExplore a larger full-stack project combining Spring Boot microservices, AWS, Keycloak, and React.

Spring Boot Unit Testing with MockitoA practical course on unit testing Spring Boot applications with Mockito. Start by writing your first unit test, then learn how to isolate repositories and service dependencies with mocks before building focused tests for business logic and REST controllers.

3 assuntos

Unit Testing FoundationsLearn the fundamentals of unit testing in a Spring Boot application and build your first isolated tests.

1 licoes

Getting Started with Unit TestingSet up the basic approach to unit testing and understand how individual application components can be tested in isolation.

Testing Repository and Service LayersLearn how to test persistence and business logic while isolating dependencies with Mockito.

2 licoes

Repository TestingBuild repository-focused tests and progressively introduce Mockito to control dependencies during testing.
Service Layer TestingUse Mockito to isolate business logic and verify how service methods interact with their dependencies.

Testing Spring Boot ControllersApply unit-testing techniques to REST controllers and verify how HTTP-facing application behavior responds to different scenarios.

1 licoes

Controller TestingBuild focused tests for Spring Boot controllers and verify their responses using mocked application dependencies.

Docker Fundamentals and Application ContainerizationLearn Docker from the fundamentals through building, managing, sharing, and composing containers, then apply those concepts by Dockerizing a React application.

4 assuntos

Docker FundamentalsLearn what Docker is, why containers are useful, and how to get a working Docker environment.

2 licoes

Understanding DockerBuild a clear mental model of Docker, containers, and images before working with them directly.
Images and ContainersWork directly with Docker images and containers and understand how they relate to one another.

Building and Managing Docker ImagesLearn how Docker images are sourced, built, cached, and managed throughout the development workflow.

3 licoes

Docker Hub and Parent ImagesUnderstand where Docker images come from and how existing images can be used as the foundation for new ones.
Dockerfiles and Image BuildsCreate custom Docker images using Dockerfiles and learn how Docker builds and caches image layers.
Managing Images and ContainersDevelop practical skills for inspecting, organizing, and maintaining Docker images and containers.

Persistent Data and Multi-Container ApplicationsLearn how Docker handles persistent data and how Docker Compose simplifies multi-container application setups.

2 licoes

Docker VolumesPersist application data independently of the lifecycle of individual containers.
Docker ComposeDefine and run applications composed of multiple containers using Docker Compose.

Dockerizing and Sharing ApplicationsApply Docker concepts to a real React application and learn how to share the resulting image through Docker Hub.

2 licoes

Dockerizing a React ApplicationApply Dockerfiles and container management to package a React application into a runnable container.
Sharing Docker ImagesPublish Docker images to Docker Hub so they can be stored and shared with other environments or developers.

Deploying Java Spring Boot Applications on AWSA practical AWS course focused on taking Java Spring Boot applications from local development into the cloud. You will work with AWS identity and access management, S3, EC2, RDS, DynamoDB, Lambda, API Gateway, SQS, SNS, Secrets Manager, Parameter Store, Docker, and ECR while building an understanding of both traditional and serverless deployment approaches.

7 assuntos

AWS Foundations and Account SetupBuild the AWS fundamentals needed to work safely with cloud resources, permissions, and costs.

3 licoes

AWS and the Java Cloud JourneyUnderstand the course roadmap and the major AWS services used to deploy Java Spring applications.
AWS Account and Cost ManagementSet up an AWS account and learn the basic safeguards for managing cloud costs.
IAM and AWS PermissionsUnderstand AWS identities, roles, groups, and permissions and apply them to application access.

AWS S3 and Application StorageUse Amazon S3 for object storage and integrate file uploads from Spring Boot applications.

3 licoes

Amazon S3 FundamentalsLearn how S3 organizes and stores objects and understand its storage options and pricing considerations.
S3 Integration with Spring BootConnect a Spring Boot application to S3 and implement application file uploads.
Static Website Hosting with S3Use S3 as a hosting location for a static website.

EC2 and Relational DatabasesDeploy Spring Boot applications on EC2 and connect them to a managed MySQL database using RDS.

4 licoes

Amazon EC2 FundamentalsUnderstand EC2 instances and the infrastructure concepts involved in running applications on AWS.
Deploying Spring Boot to EC2Deploy a packaged Spring Boot application onto an AWS EC2 instance.
EC2 Access to S3 with IAM RolesAllow a Spring Boot application running on EC2 to access S3 through an IAM role instead of application access keys.
Amazon RDS and Spring BootCreate a managed MySQL database with RDS and connect the Spring Boot application to it.

DynamoDB and Serverless ComputingExplore AWS's serverless NoSQL database and Lambda compute model and integrate them with Java applications.

2 licoes

Amazon DynamoDBUnderstand DynamoDB as a serverless, scalable NoSQL database and work with it from Spring Boot.
AWS Lambda with JavaUnderstand serverless compute with AWS Lambda and how Java applications can run as Lambda functions.

AWS CLI and Serverless APIsUse the AWS CLI and API Gateway to create and expose serverless APIs backed by Lambda.

3 licoes

AWS CLILearn to interact with AWS services from the command line.
Amazon API GatewayUnderstand API Gateway and use it to expose and manage HTTP APIs.
Building a Serverless APICombine API Gateway and Lambda to create a complete serverless API.

AWS Messaging and Application SecretsIntroduce asynchronous messaging and secure application configuration using AWS-managed services.

2 licoes

SQS and SNS MessagingUnderstand queue-based and notification-based messaging with Amazon SQS and SNS.
Managing Application SecretsUse AWS-managed services to keep sensitive application configuration outside application code.

Containerizing Spring Boot for AWSPackage Spring Boot applications with Docker and prepare container images for AWS deployment.

2 licoes

Docker for Spring BootContainerize a Spring Boot and MySQL application using Docker.
Amazon ECRUse Amazon Elastic Container Registry to store Docker images for AWS deployments.