Akka HTTP with Scala from Udemy

In this course, we will learn how to write reactive microservices, backends and REST APIs using the powerful Akka HTTP. You'll write 2000+ lines of Akka code yourself, with guidance, and you will become a rockstar.

This course is for Scala/Akka programmers who need to design large-scale reactive HTTP backends and microservices.

You probably know Akka already:

it speeds up the development of concurrent applications by as much as 10x
its demand has exploded
it's a highly marketable skill
it's incredibly fun - power in your hands.

I like to get to the point and get things done. This course

deconstructs all concepts into the critical pieces you need
selects the most important ideas and separates them into what's simple but critical and what's powerful
sequences ideas in a way that "clicks" and makes sense throughout the process of learning
applies everything in live code

The end benefits are still much greater:

a completely new mental model around stream-based microservices
a more marketable resume
more enjoyable work - Akka is fun.

This course is for established programmers with experience with Scala and Akka (including Akka Streams) at the level of the Rock the JVM courses. I already assume a solid understanding of general programming fundamentals.

This course is NOT for you if

you've never written Scala code before
you've never worked with Akka

The course is comprehensive, but you'll always see me get straight to the point. So make sure you have a good level of focus and commitment to become a badass programmer.

I believe both theory and practice are important. That's why you'll get lectures with code examples, real life code demos and assignments, plus additional resources, instructions, exercises and solutions.

I've seen that my students are most successful - and my best students work at Google-class companies - when they're guided, but not being told what to do. I have exercises waiting for you, where I offer my (opinionated) guidance but otherwise freedom to experiment and improve upon your code.

Definitely not least, my students are most successful when they have fun along the way.

So join me in this course and let's rock the JVM.

What's inside

Syllabus

Introduction

Welcome

How to Make the Best out of This Course

Scala Recap

Akka Recap

Akka Streams Recap

Akka HTTP Low-Level Server API

The Low-Level Server API

The Low-Level Server API, Part 2

Marshalling JSON

Marshalling JSON, Part 2

Handling Query Parameters

Here is where you can read more about creating certificates for HTTPS support in Akka HTTP, using the Oracle keytool:

https://docs.oracle.com/javase/8/docs/technotes/tools/unix/keytool.html

Akka HTTP High-Level Server API

High-Level Server API Intro

Directives Breakdown

Directives Breakdown, Part 2

A High-Level Server Example

A High-Level Exercise

Handling Rejections

Handling Exceptions

Routing TestKit

Websockets

Uploading Files

JSON Web Token (JWT) Authorization

Akka HTTP Client API

The Connection-Level API

The Host-Level API

The Request-Level API

Epiloguie

You Rock!

Good to know

Know what's good

, what to watch for

, and possible dealbreakers

Assumes prior experience with Scala and Akka, which allows learners to immediately dive into advanced topics and practical applications of Akka HTTP

Deconstructs concepts into critical pieces, which helps learners quickly grasp the essentials of Akka HTTP without getting bogged down in unnecessary details

Requires familiarity with Akka Streams, which may pose a barrier to entry for developers with only basic Akka experience

Includes a Scala recap, which may be helpful for learners who need a refresher on the language before diving into Akka HTTP

Covers JSON Web Token (JWT) authorization, which is a valuable skill for building secure microservices and REST APIs

Reviews summary

Mastering akka http with scala

According to learners, this course provides a deep dive into Akka HTTP, covering both low-level and high-level APIs, including crucial topics like directives, routing, and authorization (JWT). Students frequently praise the instructor's clear explanations and the effectiveness of the hands-on code examples and exercises. The course is considered highly valuable for building reactive microservices and REST APIs. While some reviewers mentioned the pace can be quick or that it requires a solid background in Scala and Akka, the overall sentiment is overwhelmingly positive, especially among experienced developers looking to master Akka HTTP.

Sections like JWT and TestKit are valued.

"The JWT section was particularly useful."

"Routing TestKit section was particularly valuable."

Covers essential Akka HTTP features.

"Good overview of Akka HTTP. Covers both low-level and high-level APIs."

"Covers most aspects of Akka HTTP."

"The section on directives was very useful."

Exercises and code examples are practical.

"...the hands-on examples help solidify the concepts."

"The hands-on exercises are very helpful for cementing understanding."

"Code is clean and easy to follow."

Instructor clarifies complex topics effectively.

"The explanations are crystal clear..."

"Instructor explains complex concepts like directives and routing in a clear, practical way."

"The instructor is knowledgeable, and the content is well-structured."

Pacing can feel fast at times.

"Some parts felt a bit rushed."

"Sometimes the pace felt a bit fast, especially on more advanced topics."

Requires prior Scala/Akka knowledge.

"Definitely requires a solid understanding of Scala and Akka Streams as stated."

"Assumes maybe too much prior knowledge."

"Requires a lot of prior knowledge."

Activities

Be better prepared before your course. Deepen your understanding during and after it. Supplement your coursework and achieve mastery of the topics covered in Akka HTTP with Scala with these activities:

Review Akka Streams Fundamentals

Show steps

Solidify your understanding of Akka Streams concepts before diving into Akka HTTP. This will make understanding the flow of data in HTTP requests and responses much easier.

Show steps

Review the official Akka Streams documentation.
Work through basic Akka Streams tutorials.
Practice building simple data pipelines with Akka Streams.

Read 'Akka in Action'

Show steps

Gain a deeper understanding of the Akka framework to better grasp the concepts used in Akka HTTP. This book provides a broader context for Akka HTTP within the Akka ecosystem.

View Akka in Action on Amazon

Show steps

Read the chapters related to Akka core concepts.
Study the examples provided in the book.
Relate the concepts to Akka HTTP functionalities.

Build a Simple REST API

Show steps

Apply your knowledge by building a simple REST API using Akka HTTP. This hands-on project will solidify your understanding of the concepts covered in the course.

Show steps

Define the API endpoints and data models.
Implement the routes using Akka HTTP directives.
Test the API endpoints using a tool like Postman.
Deploy the API to a local server.

Four other activities

Expand to see all activities and additional details

Show all seven activities

Write a Blog Post on Akka HTTP Directives

Show steps

Reinforce your understanding of Akka HTTP directives by writing a blog post explaining their usage and benefits. This will help you internalize the concepts and share your knowledge with others.

Show steps

Choose a specific set of Akka HTTP directives to focus on.
Research and understand the chosen directives thoroughly.
Write a clear and concise explanation of each directive.
Include code examples to illustrate their usage.
Publish the blog post on a platform like Medium or your personal blog.

Implement Different Authentication Schemes

Show steps

Practice implementing different authentication schemes (e.g., JWT, OAuth) in Akka HTTP to deepen your understanding of security concepts and their application in reactive microservices.

Show steps

Research different authentication schemes and their implementation details.
Choose a specific authentication scheme to implement.
Implement the authentication logic using Akka HTTP directives and libraries.
Test the authentication implementation thoroughly.

Read 'Reactive Design Patterns'

Show steps

Learn about reactive design patterns to improve the architecture and resilience of your Akka HTTP applications. This will help you build more robust and scalable microservices.

View Reactive Design Patterns on Amazon

Show steps

Read the chapters related to reactive design patterns.
Identify patterns that are relevant to Akka HTTP applications.
Apply the patterns to your existing Akka HTTP projects.

Contribute to an Akka HTTP Open Source Project

Show steps

Contribute to an open-source Akka HTTP project to gain real-world experience and collaborate with other developers. This will expose you to best practices and help you improve your coding skills.

Show steps

Find an Akka HTTP open-source project on GitHub or GitLab.
Identify a bug or feature that you can contribute to.
Fork the repository and create a new branch for your changes.
Implement the bug fix or feature and write tests.
Submit a pull request to the original repository.

Career center

Learners who complete Akka HTTP with Scala will develop knowledge and skills that may be useful to these careers:

API Developer

An API Developer specializes in creating and maintaining Application Programming Interfaces that allow different software systems to communicate. Given that this course focuses on writing reactive microservices and REST APIs using Akka HTTP, it translates directly to the skills needed for an API Developer. The course covers both low-level and high-level server APIs, marshalling JSON, handling query parameters, and implementing JSON Web Token authorization, all essential for building modern APIs. The practical exercises will ensure you gain hands-on experience.

See salaries and explore the career path for API Developer

Backend Engineer

A Backend Engineer designs, develops, and maintains the server-side logic and databases that power applications. This course on Akka HTTP with Scala is highly relevant, as it provides hands-on experience building reactive microservices and REST APIs, which are essential for modern backend systems. The substantial coding practice, coupled with the focus on stream-based microservices, helps build a strong foundation for a Backend Engineer role. Furthermore, the course covers critical aspects like handling rejections and exceptions, crucial for robust backend development.

See salaries and explore the career path for Backend Engineer

API Architect

An API Architect designs and oversees the development of APIs, ensuring they are scalable, secure, and meet the needs of the business. This course is highly beneficial as it provides extensive hands-on experience building REST APIs using Akka HTTP. The course covers essential API development topics, including marshalling JSON, handling query parameters, implementing authentication (JSON Web Token authorization), and handling rejections and exceptions. The knowledge gained from this course will help you design well-structured and robust APIs.

See salaries and explore the career path for API Architect

Microservices Architect

A Microservices Architect is responsible for designing and implementing distributed systems composed of independent, scalable microservices. This course is tailored for those building large-scale reactive HTTP backends and microservices using Akka HTTP with Scala. Given the course's emphasis on stream-based microservices and the extensive coding exercises, architects will gain practical skills in designing and implementing robust and scalable microservice architectures. The material on JSON Web Token authorization may also be particularly important.

See salaries and explore the career path for Microservices Architect

Technical Lead

A Technical Lead guides a team of developers and makes key technical decisions. This course, focusing on Akka HTTP with Scala, is directly applicable if you are leading a team building microservices and APIs. The hands-on experience with building reactive microservices and REST APIs, coupled with the comprehensive coverage of topics like marshalling JSON and implementing JSON Web Token authorization, helps you guide your team effectively and make informed architectural decisions. It will enable you to level up.

See salaries and explore the career path for Technical Lead

Software Engineer

A Software Engineer designs, develops, and tests software applications. This course provides practical experience in writing reactive microservices and backends using Akka HTTP with Scala. The hands-on coding exercises and focus on stream-based microservices will help build a strong foundation for any Software Engineer working on distributed systems or web applications. Furthermore, the coverage of topics like handling rejections and exceptions, routing with the routing testkit, and working with JSON helps you write robust code.

See salaries and explore the career path for Software Engineer

Principal Engineer

A Principal Engineer focuses on the technical strategy and architecture of large-scale software systems. This course arms Principal Engineers who want to deepen their knowledge of building reactive microservices and backends using Akka HTTP with Scala. The course's emphasis on stream-based microservices and architecture supports the design of scalable and robust enterprise applications. The concepts taught provide the vocabulary to lead teams to build the right systems.

See salaries and explore the career path for Principal Engineer

Solutions Architect

As a Solutions Architect, you will design and oversee the implementation of complex software systems. This course can be particularly relevant if your solutions involve reactive microservices and REST APIs, as it emphasizes these areas using Akka HTTP with Scala. The course's focus on practical coding and stream-based microservices helps you gain the expertise needed to design scalable and robust solutions. Knowledge of JSON Web Token authorization, learned in the course, helps you design more secure applications.

See salaries and explore the career path for Solutions Architect

Integration Engineer

An Integration Engineer works on connecting different software systems and ensuring they work together seamlessly. This course is helpful for Integration Engineers dealing with microservices and APIs built using Akka HTTP with Scala. Understanding how to build and consume REST APIs, handle JSON data, and implement authentication (JSON Web Token authorization), skills covered in the course, are vital for successful systems integration. The knowledge helps connect disparate systems effectively.

See salaries and explore the career path for Integration Engineer

Full-Stack Developer

A Full Stack Developer works on both the front-end and back-end of web applications. While this course focuses on the back-end with Akka HTTP and Scala, the skills acquired are crucial for building robust APIs that front-end applications consume. Experience with reactive microservices, REST APIs, and handling JSON, all covered extensively in the course, will give you a comprehensive understanding of building modern web applications. The practical coding will also prove invaluable for creating efficient backends.

See salaries and explore the career path for Full-Stack Developer

Application Developer

An Application Developer specializes in creating software applications for specific platforms or purposes. This course, focused on Akka HTTP with Scala, may be relevant for Application Developers building back-end services and APIs. The course's emphasis on reactive microservices and REST APIs translates directly to skills needed for modern application development. The practical coding exercises and coverage of topics like JSON Web Token authorization help you build secured backend services.

See salaries and explore the career path for Application Developer

Software Developer

A Software Developer is a broad term encompassing individuals who write and maintain code for various types of applications. This course on Akka HTTP with Scala may be useful for Software Developers who want to specialize in building reactive microservices and REST APIs. The hands-on coding exercises and coverage of topics like marshalling JSON, handling query parameters, and exception handling help you write efficient and reliable code. The end result enables you to produce more marketable resume for Software Developer roles.

See salaries and explore the career path for Software Developer

Systems Architect

A Systems Architect designs the overall structure of IT systems, considering hardware, software, and network components. This course, with its focus on building reactive microservices and backends using Akka HTTP with Scala, may be relevant if your systems architecture involves distributed, scalable applications. The understanding of stream-based microservices, gained from this course, translates well to designing efficient and resilient systems. The course's coverage of security aspects like JSON Web Token authorization is also valuable.

See salaries and explore the career path for Systems Architect

Cloud Engineer

A Cloud Engineer is responsible for designing, implementing, and managing cloud-based infrastructure and services. This course may be useful for Cloud Engineers who need to develop and deploy microservices and APIs on cloud platforms. Knowledge of Akka HTTP with Scala helps in building scalable and reactive applications suitable for cloud environments. The course's coverage of topics like handling rejections and exceptions, routing, and JSON Web Token authorization adds to the reliability of cloud applications.

See salaries and explore the career path for Cloud Engineer

DevOps Engineer

A DevOps Engineer automates and streamlines the software development and deployment process. This course may give DevOps Engineers insights into building and deploying microservices and APIs using Akka HTTP with Scala. Familiarity with the technologies used in application development helps DevOps Engineers in optimizing deployment pipelines and infrastructure. Understanding how applications handle rejections and exceptions helps in monitoring and troubleshooting production systems.

See salaries and explore the career path for DevOps Engineer

Reading list

We've selected two books that we think will supplement your learning. Use these to develop background knowledge, enrich your coursework, and gain a deeper understanding of the topics covered in Akka HTTP with Scala.

Reactive Design Patterns

Save

Explores design patterns specifically tailored for reactive systems. Understanding these patterns will help you build more resilient, scalable, and maintainable Akka HTTP applications. It provides valuable insights into handling concurrency, fault tolerance, and asynchronous communication in reactive environments. This book is more valuable as additional reading to deepen your understanding of reactive principles.

Reactive Design Patterns

Paperback

Akka in Action

Save

Provides a comprehensive overview of the Akka framework, including actors, concurrency, and fault tolerance. It offers practical examples and real-world scenarios that can help you understand how to build robust and scalable applications with Akka. While not solely focused on Akka HTTP, it provides a strong foundation for understanding the underlying principles of Akka, which are essential for mastering Akka HTTP. It useful reference for understanding the broader Akka ecosystem.

Akka HTTP with Scala

What's inside

Syllabus

Good to know

Save this course

Reviews summary

Mastering akka http with scala

Activities

Career center

Reading list

Share

Similar courses