Name: The Complete Strapi Course - with plugins and deployment
Rating: 4.5 (553 reviews)

Udemy Business

Teach on Udemy

Turn what you know into an opportunity and reach millions around the world.

Learn More

Your cart is empty.

Keep shopping

Created byArtcoded Academy (by Jib)

Last updated 7/2024

English

What you'll learn

Master the Strapi 4, the leading headless CMS, from the basics to advanced skills
Create a complete Strapi application, with custom features and a full plugin
Learn Strapi basics: content types, relations, components, dynamic zones, and more
Customize the Strapi REST API with custom routes, controllers, services, etc.
Customize the Strapi GraphQL API with custom operations
Interact with your app via Strapi's REST and GraphQL API
Learn Strapi plugins development by creating a full plugin (admin UI included)
Deploy Strapi with 2 different architectures and CI/CD pipeline

Course content

11 sections • 144 lectures • 15h 1m total length

Course teaser3:33
The course presentation video
Course structure: optimize your learning path3:10
An overview about the course structure, to plan and optimize your learning path

What is Strapi6:30
Learn what is Strapi with this introduction
Course Project: an overview5:02
Get an overview of the developer blog application we'll build throughout this course
Install and manage NodeJs with NVM6:17
Install NodeJs using Node Version Manager
Project repository (for reference)0:22
Creating the Strapi project2:05
Create the Strapi project for our developer blog application
More on Strapi installation1:21
More info on what the Strapi installation script performed for us
How to use Typescript (optional)7:55
How to adopt Typescript for your Strapi project
Admin panel: users, roles and initial tour8:56
Learn to distinguish admin users from application users, and get an overview of the admin panel sections
How to update Strapi3:42
Instructions on how to update Strapi to a more recent version

Content types: an introduction3:26
Learn what Strapi content types are and start creating the Post content type
Data fields: foreword0:38
Data fields4:52
Explore all field types
Adding fields to a content type4:40
Start adding fields to our Post content type
Creating the Tag collection type1:13
Create our second collection type
Relation fields8:38
Create and understand relation fields
Components8:45
Understand Strapi components and create our first one
Using the Content Manager7:59
Use our first 2 content types to create some content instances by using the Content Manager
Creating Service and Course content types3:07
Create two new collection types needed for our application
Creating a single content type9:49
Start creating our first single content type for our blog's Home Page
Creating a component for Posts Selection3:29
Creating a dynamic zone5:16
Learn about dynamic zones and create a first zone
Creating the Home Page content entry4:51
Populate the HomePage single content type with content, thus also learning how to use dynamic zones
Fixing the Home Page3:43
Fix the component tree of the Home Page
Creating a global configuration type5:41
Creating a CompanyInfo component for setting up global configuration parameters for our site
Creating Header and Footer types3:39
SEO and page challenge3:04
Finishing the blog application7:53
Strapi architecture: generated code overview6:15

Install some tools1:09
A couple of tools to install to follow along with the course
Performing public API operations6:14
Enable and perform our first public REST API call
Authentication & Authorization: the theory5:40
Learn how Authentication & Authorization flows work in Strapi
Performing User Authentication via API6:14
Sign a user up via API
Performing our first authenticated operation2:35
Perform a request as an authenticated user, by applying the needed auth header
API tokens2:00
Learn how to manually generate tokens to grant access to Strapi API

CRUD operations on Collection Types6:02
Learn about the default CRUD endpoints for Collection Types, with examples
CRUD operations on Single Types4:36
Learn about the default CRUD endpoints for Single Types, with examples
API parameters: an introduction3:43
Sort the API response3:01
Filter your API responses3:04
Populate your API responses with relations and more6:44
Select fields for your API responses1:33
Paginate through content via API2:36
Deal with draft content via API2:12

Customizing Strapi: what we’ll build1:32
Strapi architecture: an overview4:56
Request and Response4:09
Data models and APIs6:58
Lifecycle hooks4:11
Configuring core routes5:54
Creating custom routes3:07
Policies13:44
The Strapi object4:24
Middleware9:13
Controllers: creating custom controllers8:54
Controllers: extending core controllers4:01
Controllers: replacing core controllers7:06
Services11:37
Entity Service and Query Engine APIs5:59
Premium posts: introduction7:02
Premium posts: solution 15:38
Premium posts: solution 217:29
Premium posts: solution 37:11
Premium posts: the findOne controller8:20
Post likes: part 111:21
Post likes: part 214:12
Lifecycle hooks: the theory2:56
Lifecycle hooks exercise: part 1 (challenge)6:04
Lifecycle hooks exercise: part 2 (challenge solution)2:48
Lifecycle hooks exercise: part 3 (first programmatic hook)16:07
Lifecycle hooks exercise: part 4 (second programmatic hook)6:23
Lifecycle hooks exercise: part 5 (declarative hook)12:00
Webhooks: an overview4:31

Introducing our Strapi plugin “Github Projects”7:36
Overview and demo of the plugin we'll be developing
Creating and activating a plugin4:04
We generate our plugin from the CLI and "register" it to the Strapi core
Integrating the third-party Github API4:27
Install dependencies and configure env variables to interact with the Github remote API
Plugin route, controller and service7:28
We start tweaking the default generated plugin route-controller-service chain to meeting our Github fetching needs
Fetching data from the Github API4:49
Performing our Github API call to fetch repositories
Adapting the API response8:08
Enriching and filtering our API response to shape it as an array of "repository" objects
Creating the Project content type9:42
Create the Project content type associated to our plugin
Creating a test Project2:54
Manually create a test Project entity to be able to start testing our functionalities
Fetching related projects5:52
Get information for each repo on the existance of an already generated project associated to it
Dealing with markdown content3:19
Optimized fetched markdown text for repos to be properly handled in Strapi
Admin panel: plugin icon and first component4:34
Change the plugin logo and create a first custom React component
The Strapi design system6:45
Introduction to the Strapi UI design system
Fetching data from the admin panel8:36
Fetch Github repositories with an API call from the Admin panel UI of our plugin
Showing data in a table5:47
Start populating our Admin Plugin UI with a table listing Github repositories
Setting up the action icons3:55
Add dynamic action icons for each repository shown in the table
Implementing the checkbox logic13:07
Add functionality to select/deselect repositories/rows through the checkboxes, individually or in bulk
Applying the proper auth policy to our route1:50
Change our repo fetching route's policy to allow that operation only for authenticated admin users
Generating a single project14:08
Generate a Project programmatically from a single repository via a custom route-controller-service chain
Providing UI feedback to the admin user15:29
Implement table instant update and alerts to provide proper feedback to user operations
Deleting a project10:02
Delete a project programmatically from repository rows
Showing a confirmation dialog before deleting12:54
Prevent deleting projects by mistake by adding a confirmation dialog for project deletion
Showing buttons for bulk actions13:30
Add buttons to perform bulk project creation/deletion
Creating projects in bulk17:12
Generate multiple projects in bulk
Deleting projects in bulk13:46
Delete multiple projects in bulk
Admin RBAC: update premise1:26
Admin RBAC: restricting plugin use to specific roles11:24
Apply role-based restrictions that limit the access to the plugin
Admin RBAC: restricting routes to specific roles10:21
Admin role-based restrictions for specific routes
Fixing error handling6:12
Apply the then/catch syntax to properly handle errors
Exposing projects with public routes8:28
Expose projects for public read access
Plugin localization8:18
Translate the plugin in multiple languages
Extract the plugin as a separate package6:21
Extract our plugin as a standalone package
Publish the plugin to npm registry2:49
Publish the plugin as an npm package on the npm registry
Install the plugin as a dependency (and publish to the Strapi Market)3:27
Install the plugin as a remote NPM package, while also learning how to publish a plugin to the Strapi Marketplace

Requirements

Basic knowledge of Javascript is enough
For the Strapi Plugins section (only the admin UI part), a basic knowledge of React is useful

Description

The definitive course to learn Strapi™ v4 from the basics to advanced usage!

Why Strapi and why this course?

This course is perfect for anyone that wants to add Strapi to their developer toolbox, being it the most popular headless CMS in the market (and still growing!), which combines top-level out-of-the-box features with strong flexibility and extensibility.

Build and deploy a complete Strapi app, plus a complete plugin!

In this course I will drive you from the very basic concepts to building, customizing and deploying a complete Strapi application.

The application we'll be creating includes features built by extending the Strapi core via custom logic (routes, controllers, GraphQL resolvers, etc.). Furthermore, in this course you'll be developing a complete plugin (admin + server code), that is ready to be published on the Strapi Market (and in fact you will find it there now!).

Let me say that the Strapi Plugin section is a course in the course, and it will give you the skills to propose Strapi plugins to customers, both through the newborn Strapi market (that has high growth potential) and directly.

Course topics list

Here are the main topics you will be learning:

Working with content: content types, fields, relations, components, dynamic zones
Authorization & authentication system
Working with the REST API
Working with the GraphQL API
Extending Strapi core: custom routes, controllers, services, policies, middleware
Extending the GraphQL plugin
Customizing the Admin Panel
Creating a complete plugin (server and admin included), ready for the Strapi marketplace
Deploying Strapi in production

What you'll be able to do afterwards

By the end of this course, you will feel empowered as you'll master a framework that dramatically speeds up time to market in developing production-ready backend applications, while not sacrificing extensibility to adapt it to endless use cases and business requirements!

Disclaimer

The Strapi™ name and logo are property of Strapi Solutions SAS and are shown, as well as parts of the Strapi application, for educational purposes. This course is published independently, with no affiliation with Strapi Solutions SAS.

Who this course is for:

Whoever aims at fully mastering the n. 1 headless CMS in the market
Front-end developers who see in Strapi the best way to embrace full-stack development
Back-end engineers who see in Strapi the most efficient and flexible development framework

What you'll learn

Explore related topics

Course content

Welcome to the course2 lectures • 7min

Introduction9 lectures • 42min

Designing Strapi content types19 lectures • 1hr 37min

Permissions, authentication and authorization6 lectures • 24min

Working with REST API9 lectures • 34min

Working with GraphQL8 lectures • 37min

Extending Strapi core: custom controllers and more29 lectures • 3hr 38min

Extending the GraphQL API8 lectures • 44min

Customizing the Strapi Admin5 lectures • 23min

Strapi plugin development: create a plugin33 lectures • 4hr 19min

Requirements

Description

Who this course is for: