4.38 (573 reviews)
☑ Build multiple different microservices using Lumen de Laravel
☑ Create a service-oriented architecture from scratch using the Lumen microframework
☑ Implements a complete security system to control access to internal and external architectural services
☑ Feel confident to create and implement service-oriented architectures using Lumen de Laravel
☑ Master the best practices of construction and implementation of a complete architecture oriented to services
Implement from scratch a complete service-oriented architecture with PHP, using Lumen by Laravel.
Lumen is a PHP microframework based on Laravel (a PHP framework), which makes it ideal to implement microservices along with rapid and light systems.
During this course, I will show you the whole process to implement a service-oriented architecture with PHP and using Lumen; implementing a set of microservices and its interactions. Build the entire security and interaction systems between each microservice. All of that using PHP with Lumen.
So, do not wait any more, and enroll now :)
Why should you take this course?
Because it gives you a detailed view, as in no other course, of a service-oriented architecture that is fully functional and secured using PHP and Lumen.
Because you will be able and confident enough to implement your microservices and architectures using Lumen and PHP.
Because it not only shows you the benefits of microservices and their architectures but also shows you how to solve the challenges that microservices represents
Because it shows you how to secure all the microservices in the architecture and control the access to them
What will you be able to do at the end of the course?
In general, you will be able to implement any microservices architecture you need using PHP and Lumen. You will have a clear idea of how to implement each microservice with Lumen, as well as how the interaction between each of these microservices should be structured, how to build a complete security layer that protects and restricts access to each microservice in the architecture using OAuth2 with Lumen/Laravel Passport along with authenticate users and use different grant types of OAuth2.
You will feel confident to take your path and carry out your projects with all the microservices and components you want with PHP and Lumen.
What will you learn exactly?
Create projects in Lumen by Laravel
Configure and use Lumen easily in your system without complex processes
Use Lumen properly for its ideal purpose: the microservices
Build a fully functional service-oriented architecture from scratch
Use OAuth2 to protect access to your architecture, through Lumen/Laravel Passport
Install and adapt Laravel Passport to Lumen projects
Create access tokens associated with users to handle users data and authorization flows
Authenticate users credentials and restrict access to only valid users if needed
Authorize and use different kinds of access tokens to restrict the action over your resources
Create a complete system of interaction between microservices through HTTP requests with GuzzleHTTP from Lumen
Build fully functional and adequate services with Lumen
Returns and builds standardized JSON responses with Lumen
Separate the components of a service-oriented architecture appropriately
Handle errors and exceptions appropriately to ensure the consistency of the entire architecture
Build and implement, correctly, an API Gateway for your architecture
Centralize the consumption of your service-oriented architecture through an API Gateway with Lumen
And a lot much more. You will have access for life to each class that makes up the course and those that will come later. You also have direct access to me, so you can ask me questions and solve all your doubts.
Do not wait any longer, cheer up and join the course and give free rein to all the possibilities that Lumen offers with a service-oriented architecture.
About the instructor and the course
About the microservices architecture and Lumen
The source code of the course
Make sure you have understood the architecture you will implement with Lumen.
Creating a first microservice for authors with Lumen
Obtaining the Lumen structure for the authors' service
About the development environment to use in the course
Preparing the service for its correct operation
Building the authors table with a migration of Lumen
Creating the authors' model
Creating a factory for authors and building test values
Creating the controller for authors
Creating the routes for CRUD operations on the authors
Normalizing the authors' microservice responses
Make sure you understand several essential concepts and components
Implementing the functions of the authors' microservice in Lumen
Showing the list of authors from the Lumen controller
Allowing creating author instances from the controller
Allowing showing an author with a given id with Lumen
Allowing editing an existing author
Allowing deleting an existing author
Handling important errors and exceptions with Lumen
Creating the book microservice with Lumen
Getting the structure of Lumen for the book microservice
Preparing the books microservice
Creating the table for books with migrations
Creating the model for books
Creating a factory for books and generating random values
Creating the Lumen controller for books
Creating the Lumen routes for CRUD operations on books
Standardizing the responses across the services
Implementing the microservice functions for books in Lumen
Showing the complete list of books
Allowing creating new instances of books
Allowing showing a specific book
Allowing updating an existing book
Allowing removing an existing book
Handling relevant errors and exceptions with Lumen
Creating and preparing the API Gateway with Lumen
Creating the Lumen project for the API Gateway using Composer
Preparing Lumen for the API Gateway
Creating the controllers for the authors and books Lumen microservices
Unifying Lumen responses for the API Gateway
Registering routes for microservices in Lumen from the Gateway
Preparing the Gateway in Lumen to consume services
Preparing the Lumen components to consume the internal services
Implementing the functions of the Gateway with Lumen
Obtaining the list of authors from the authors' Lumen microservice
Creating an author instance with the authors' service
Showing an author instance using the authors' Lumen microservice
Editing author instances using the authors' service
Deleting author instances using the authors' Lumen service
Implementing operations for books based on the authors ones
Checking the existence of the author before creating a book
Controlling errors obtained from services
Implementing the security layer of the microservices architecture with Lumen
Installing and enabling Lumen Passport components
Preparing and configuring Lumen to use Passport
Protecting the Gateway routes with Lumen Passport
Obtaining and using access tokens for the Lumen API Gateway
Preparing the API Gateway to authenticate its requests
Authenticating direct access to the Lumen authors microservice
Authenticating direct access to the microservice of books
Authenticating user access with access tokens
Creating the migration for the users table in Lumen
Creating the controller and the routes to manage users in Lumen
Fixing some details related to user operations
Creating users and creating access tokens associated with users
Identifying an authenticated user through access token
Conclusions and recommendations
Considerations to keep in mind with your microservices
Thanks for getting here
It is what it is as in the description. You may need to make little changes in the Laravel/Lumen 8.0.x, but its clearly seen from the app's structure and fits well on the 8.0 too. The only half a point downside is, the lecturer is going too fast at the first courses (I need to look up what does it mean facades, eloquent in Laravel in to the web). Otherwise this course is well enough for the creating microservices with Lumen.
Very help full course, it give me knowledge about microservices and give me basic structure of microservices's project
Excellent course! sometimes it's a little repetitive duplicating the same structure/behavior between component but it is a good point to start. Thank you
Good basic, brief, practical class in implementing microservices with Lumen. If you are a beginner and are interested in 'how' but not 'why', this course is for you.
It was a clear view how to build an ApiGateway ,several microservices along with OAuth and access tokens implementation. Very nice. However, some patterns like model validation should have been presented in a different way following the framework's capabilities (model rules should have been used inside the model instead of the controllers, validate method should have been executed within-before the models save(), update() etc) keeping the separation of concerns clear. In general, the course was good and the instructor was understandable and contagious. Good job!
I am having a great experience by taking this course and this course is very content-specific and easy to understand.
What made me decide to buy this course is because of the shown architecture image. Plus the instructor is a contributor of passport itself. Great course btw.
Too much duplicate content, to much time passed to explain basic concept. I mean it's not an course introduction to lumen but how manage microservice with lumen. More time and other way to authenticate would be fine (like manage permission in internal services)
The course is good and reader can take good inputs from this.. this can be more on api gateway than general laravel stuff.. that is only the concern i saw by the way thankyou this course
The course met my expectations. It taught me what I set out to learn: how to set up authentication in a micro-service architecture.
Was hoping for some more explanation of the Lumen Framework and what can be done with it.... but guess that's for another course. Please go a bit slower when adding the typical "use" statements - this goes a bit quick and seems you have some sublime plugin to automatically add. Missed out on that part a few times and had to jump to the git code to get it all right. Thanks for a great course.
The course material has been good so far, but it is very difficult to understand what the instructor is saying due to the accent. I've had to go back and replay the same videos a few times to comprehend.
TL;DR: it covers only the bare essentials of the microservices architecture. About 75% of the course is mostly a walk-through about how to create routes, controllers, etc... which will surely give beginners a firm grasp of those topics. This however left me a little disappointed as I was expecting the course to give some more in-depth analysis of the architecture, maybe some design patterns and tradeoffs and/or just how to deal with more complex stuff in general. And the proposed Books and Authors example is very basic (no relationships, etc).
I found this to be a good introductory course in Lumen and covered many of the features that I was expecting.
The explanation was so detail, and I also like guided step by step in following this course, but the auto-generated subtitle was so weird. I don't know it's because of the tutor's pronunciation or the subtitle generator itself. I think it's because the subtitle generator because sometimes the tutor's pronunciation is pretty clear, but the generated subtitle is still weird. One thing, maybe the tutor should give additional info about what plugin that he used in his Sublime Text wkwk.