CF

Let's Build a Go version of Laravel: Part Two

8h 5m 42s
English
Paid

Welcome back! This is the follow-up to "Let's Build a Go Version of Laravel" and is specifically crafted for students who have already embarked on the initial journey. In the first part of this series, we developed a reusable Go module packed with features such as HTML, JSON, and XML response types, support for Go and Jet templates to render pages, multiple database support, sessions, and more. Now, we aim to enhance our Celeritas package with new functionalities:

New Functionalities

  • Support for Remote File Systems: Seamlessly integrate with Amazon S3 buckets, Minio, sFTP, and WebDAV.

  • Social Authentication: Easily add authentication via GitHub and Google, with the flexibility to include more providers.

  • Enhanced Testing: Incorporate improved testing features, including a Go version of Laravel's Dusk, which captures browser screenshots during functionality tests.

  • Maintenance Mode: Leverage Remote Procedure Calls (RPC) to control maintenance mode efficiently.

  • Database Migrations: Support both raw SQL and soda's Fizz file format for improved database migrations.

  • File Upload Functionality: Implement robust file upload features supporting local and remote file systems.

  • Separate Logic and Routes: Differentiating between web and API routes for better organization and performance.

  • Test Creation Simplified: Facilitate test creation by pre-populating stub test files and providing setup_test.go files for projects.

By the conclusion of this course, you will possess not only a comprehensive understanding of all the topics covered above but also a reusable code base designed to accelerate your future projects.

About the Author: Udemy

Udemy thumbnail

Udemy is the largest open marketplace for online courses on the internet. Founded in 2010 by Eren Bali, Oktay Caglar, and Gagan Biyani and headquartered in San Francisco, the company went public on the Nasdaq in 2021 under the ticker UDMY. The platform hosts well over two hundred thousand courses across software development, IT and cloud, data science, design, business, marketing, and creative skills, taught by tens of thousands of independent instructors. Roughly seventy million learners use it worldwide, and the corporate arm — Udemy Business — supplies a curated subset of that catalog to enterprise customers.

Because Udemy is a marketplace rather than a single editorial publisher, the catalog is uneven by design. The strongest material lives in the long-form, project-based courses authored by working engineers — full-stack JavaScript, React, Node.js, Python data science, AWS, Docker and Kubernetes, mobile development with Flutter and React Native, and cloud certification preparation. The CourseFlix listing under this source is the slice of that catalog that has been mirrored here for offline-friendly viewing, organized by topic and updated as new releases land. Pricing on Udemy itself swings dramatically with the site's near-permanent sales, which is why the platform is best treated as a deep reference catalog: pick instructors with strong reviews and a track record of updating their material rather than buying on the headline price alone.

Watch Online 103 lessons

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 103 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Introduction
All Course Lessons (103)
#Lesson TitleDurationAccess
1
Introduction Demo
03:02
2
About me
01:02
3
Asking for help
01:15
4
Installing Go
01:40
5
Installing an IDE
01:18
6
Setting up the project
05:57
7
Making sure everything worked
03:26
8
What we're going to create
02:26
9
Setting up our remote file systems using Docker
04:37
10
Configuring Minio
02:32
11
Configuring sFTP
03:09
12
Setting up a type for file systems
06:45
13
Getting started with Minio: connecting and the Put function
10:35
14
Implementing the List function in Minio
06:36
15
Implementing the Delete function in Minio
03:13
16
Implementing the Get function in Minio
03:23
17
Creating stub filesystems for the other three types
05:40
18
Adding filesystems to Celeritas
07:05
19
Trying out our Minio filesystem
04:14
20
Creating a handler to list the remote file system
10:52
21
Connecting the handler to a route and trying things out
01:39
22
Creating handlers to display the upload form
03:28
23
Creating the handler to process the file upload
11:13
24
Creating the delete handler
06:03
25
Implementing the Put function for sFTP
10:31
26
Implementing the List function for sFTP
04:05
27
Implementing the Delete function for sFTP
02:07
28
Implementing the Get function for sFTP
04:58
29
Connecting Celeritas to our sFTP file system
02:42
30
Updating our ListFS handler to support sFTP
02:12
31
Updating our PostUploadToFS handler to support sFTP
03:34
32
Updating our DeleteFromFS handler to support sFTP
01:20
33
Cleaning up the Get function to avoid resource leaks
03:56
34
Implementing the Put function for WebDAV
06:12
35
Implementing the List function for WebDAV
03:20
36
Implementing the Delete function for WebDAV
02:15
37
Implementing the Get function for WebDAV
03:55
38
Testing things out
06:25
39
Implementing the List function for S3 file systems
11:14
40
Implementing the Put function for S3 file systems
07:18
41
Implementing the Delete function for S3 file systems
05:28
42
Implementing the Get function for S3 buckets
03:52
43
Connecting Celeritas to our S3 file system
02:13
44
Creating an S3 compatible bucket on Linode
04:36
45
Updating our handlers for S3 buckets
01:40
46
Trying things out
03:14
47
What we'll build
01:38
48
Adding file systems to the Celeritas type
02:10
49
Creating the file uploader
06:52
50
Limiting upload by mime type
06:20
51
Adding the mime type and file size limitations to the Celeritas config type
06:02
52
Setting up handlers and routes to try things out
06:02
53
Trying things out
03:26
54
Pop vs. SQL
04:32
55
Getting started with Pop functions for our migrations code in Celeritas
03:39
56
Implementing the CreatePopMigration() function to create up and down migrations
02:37
57
Implementing the RunPopMigrations() function
02:21
58
Implementing the PopMigrateDown() function
03:26
59
Implementing the PopMigrateReset() function
01:22
60
Making changes in the Celeritas CLI for our pop migrations
10:25
61
Trying out our new make migration command
03:20
62
Ensuring the database is connected before allowing people to make migrations
03:42
63
Creating a database.yml file and running migrations
05:54
64
Trying out the migrate command
02:35
65
Updating the "make auth" command for our Pop integration
06:40
66
Trying out make auth
03:00
67
Social Authentication or Single Sign On: an Overview
03:38
68
Getting started with Goth and Social Authentication
03:38
69
Setting up authentication routes
04:10
70
Initializing social sign on
07:24
71
Implementing the SocialLogin handler
05:18
72
Implementing the SocialCallback handler
11:37
73
Connecting our social authentication handlers to routes
01:48
74
Setting up GitHub for social authentication
03:30
75
Trying out the GitHub login functionality
05:52
76
Logging out
05:22
77
Really logging out
09:51
78
Trying the socialLogout function
01:53
79
Adding support for Google login
04:01
80
Updating the auth-handlers.go file for Google to enable login
02:28
81
Trying out login with Google
02:01
82
Adding the case for logging out of Google in socialLogout()
01:59
83
Trying things out
01:30
84
Separating Web and API routes
05:07
85
Getting started with "Maintenance Mode" functionality using RPC
09:21
86
Starting RPC
00:58
87
Adding maintenance mode middleware
06:28
88
Updating the CLI for maintenance mode
05:12
89
Testing the maintenance mode functionality
03:39
90
Graceful Shutdown
08:01
91
Adding a simple setup_test.go file to handlers
09:34
92
Adding two functions to our setup_test.go file
02:53
93
Adding and running a sample test
04:44
94
Adding some additional tests
05:05
95
Implementing Laravel Dusk like screen captures
02:08
96
Writing the screen capture function
07:58
97
Trying out the screen capture function
04:45
98
Writing additional helper functions for testing
14:31
99
Updating our templates in the CLI, and making some changes to the myapp
08:15
100
Creating our skeleton app
04:33
101
Additional updates to the skeleton application and the celeritas project
04:31
102
Trying out the "celeritas new <project>" command
02:18
103
Trying things out
05:21
Unlock unlimited learning

Get instant access to all 102 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Related courses

Frequently asked questions

What are the prerequisites for enrolling in this course?
This course is a continuation of 'Let's Build a Go Version of Laravel' and is specifically designed for students who have completed the initial part. Familiarity with the Go programming language, setting up a Go environment, and basic understanding of the Celeritas package from the first course are necessary to follow along.
What projects or applications will I build during this course?
Students will work on enhancing the Celeritas package with functionalities such as integrating remote file systems like Amazon S3, Minio, sFTP, and WebDAV. Additionally, you will implement social authentication, database migrations using both raw SQL and soda's Fizz format, and a robust file upload system.
Who is the target audience for this course?
The course is intended for developers who have completed the first part of the series and are interested in building a Go-based framework similar to Laravel. It is suitable for those looking to enhance their web development skills using Go and implement advanced features like social authentication and remote file handling.
What specific tools or platforms will I learn to integrate with?
The course covers integration with remote file systems such as Amazon S3, Minio, sFTP, and WebDAV. It also includes setting up social authentication with providers like GitHub and Google, and working with database migration tools such as Pop and SQL.
How does the depth of this course compare to other similar courses?
This course provides a detailed exploration of building a Go framework akin to Laravel, focusing on adding advanced functionalities to the Celeritas package. It offers practical lessons on implementing remote file systems, social authentication, and database migrations, which may not be as extensively covered in other courses centered on Go.
What topics are not covered in this course?
The course does not cover basic Go programming concepts, as it assumes students have already completed the first part of the series. It also does not delve into front-end development or user interface design, focusing instead on server-side functionalities and integrations.
What is the expected time commitment for completing this course?
The course consists of 103 lessons, which vary in length and complexity. While the total runtime is not specified, students should allocate sufficient time to engage with the lessons, complete practical exercises, and implement the functionalities discussed. A commitment of several hours per week is recommended to make steady progress.