Key Features of Akka HTTP :

1. Reactive Programming:

   • Built on Akka, it follows the principles of reactive streams and enables asynchronous, non-blocking communication.

2. Server-Side and Client-Side APIs:

   • Server-Side: Easily build RESTful HTTP APIs or services.
   • Client-Side: Interact with external HTTP-based services.

3. High Scalability and Performance:

   • Uses actor-based concurrency from Akka, making it suitable for handling a high volume of requests efficiently.

4. Streaming Support:

   • Fully supports streaming of large data (e.g., files or continuous data streams).

5. Modular Design:

   • Provides flexible components that can be used independently, including routing, unmarshalling, marshalling, and connection handling.

6. Routing DSL:

   • Includes a declarative routing DSL for defining API endpoints in a clear and concise way.

7. Integration with Akka Ecosystem:

   • Seamlessly integrates with Akka actors, streams, and Akka Typed, enabling tight coupling with the rest of the Akka toolkit.

8. Lightweight:

   • Unlike traditional HTTP frameworks, Akka HTTP doesn't impose a large framework structure and can be used as a library in applications.

9. Pluggable Components:

   • Easily extendable with custom logic, such as custom directives, unmarshallers, and marshallers.

Core Components of Akka HTTP :

Akka HTTP is designed around a set of modular components that work together to provide flexible, reactive, and high-performance HTTP functionalities. Here are its core components:

1. HTTP Model

• Description: A set of immutable classes and objects representing HTTP requests, responses, headers, and entities.
• Purpose: Provides a type-safe and consistent way to work with HTTP messages.
• Key Elements:
  • HttpRequest: Represents an HTTP request.
  • HttpResponse: Represents an HTTP response.
  • HttpEntity: Encapsulates the body of a request or response.
  • Headers: Standard and custom headers like Authorization, Content-Type, etc.

val request = HttpRequest(uri = "/api/data")
val response = HttpResponse(entity = "Hello, Akka HTTP!")?

2. Routing DSL :

• Description: A high-level declarative API for defining HTTP endpoints and handling requests.
• Purpose: Simplifies creating RESTful APIs by abstracting HTTP handling logic.
• Key Features:
  • Match HTTP methods (e.g., GET, POST).
  • Match paths or query parameters.
  • Process requests and send responses.

val route =
  path("hello") {
    get {
      complete("Hello, World!")
    }
  }?

3. Directives :

• Description: Building blocks for routing logic, encapsulating common operations like path matching, header extraction, and request processing.
• Purpose: Provide composable components for building routes.
• Types of Directives:
  • Path Directives: Match specific paths (path, pathPrefix).
  • Method Directives: Match HTTP methods (get, post).
  • Header Directives: Extract headers (optionalHeaderValueByName).
  • Entity Directives: Extract and process request bodies (entity).

val route =
  path("user" / IntNumber) { userId =>
    get {
      complete(s"Fetching user with ID: $userId")
    }
  }?

4. Marshalling and Unmarshalling :

• Description: Converting objects into HTTP entities (marshalling) and vice versa (unmarshalling).
• Purpose: Enables serialization and deserialization of data (e.g., JSON, XML).
• Common Libraries:
  • Akka HTTP integrates well with libraries like Spray JSON or Jackson.

import spray.json._
import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._

case class User(name: String, age: Int)
object UserJsonProtocol extends DefaultJsonProtocol {
  implicit val userFormat = jsonFormat2(User)
}

import UserJsonProtocol._

val route =
  path("createUser") {
    post {
      entity(as[User]) { user =>
        complete(s"Received user: ${user.name}")
      }
    }
  }?

5. Akka Streams :

• Description: A reactive streams-based toolkit used for processing data streams asynchronously and non-blockingly.
• Purpose: Enables streaming data handling in Akka HTTP, such as processing large files or continuous data streams.
• Key Features:
  • Backpressure handling.
  • Easy integration with HTTP entities.

import akka.stream.scaladsl.Source
val numbers = Source(1 to 100)
val route =
  path("stream") {
    get {
      complete(numbers.map(_.toString))
    }
  }?

6. Connection Layer :

• Description: The lower-level layer responsible for handling HTTP connections, requests, and responses.
• Purpose: Provides direct control over the HTTP connection lifecycle.
• Key Features:
  • Start an HTTP server.
  • Create HTTP clients for external API interactions.
• Example: Starting a server.

import akka.http.scaladsl.Http
import akka.http.scaladsl.model._

val responseFuture = Http().singleRequest(HttpRequest(uri = "https://api.example.com/data"))?

7. Client-Side API :

• Description: A high-level API for making HTTP requests to external services.
• Purpose: Allows interaction with RESTful APIs or HTTP servers from Akka-based applications.
• Key Features:
  • Send requests and receive responses.
  • Streaming and non-blocking support.

import akka.http.scaladsl.Http
import akka.http.scaladsl.model._

val responseFuture = Http().singleRequest(HttpRequest(uri = "https://api.example.com/data"))?

8. TestKit :

• Description: Tools and utilities for testing Akka HTTP routes and applications.
• Purpose: Simplifies writing unit tests for routes and APIs.
• Key Features:
  • Simulate HTTP requests.
  • Validate responses and statuses.

import akka.http.scaladsl.testkit.ScalatestRouteTest
import org.scalatest.matchers.should.Matchers
import org.scalatest.wordspec.AnyWordSpec

class MyRouteTest extends AnyWordSpec with Matchers with ScalatestRouteTest {
  val route =
    path("test") {
      get {
        complete("Test successful")
      }
    }

  "The service" should {
    "return a successful response for GET /test" in {
      Get("/test") ~> route ~> check {
        responseAs[String] shouldEqual "Test successful"
      }
    }
  }
}?

Advantages of Akka HTTP :

• Asynchronous and Non-Blocking: Handles a large number of requests with minimal resource usage.
• High Performance: Suitable for real-time, high-throughput applications.
• Scalable: Built on Akka's actor model, it easily scales horizontally and vertically.
• Flexible and Modular: Offers components that can be used as needed, without a heavy framework overhead.
• Streaming Support: Simplifies the handling of streaming data.

Disadvantages of Akka HTTP :

• Steeper Learning Curve: Requires knowledge of Akka and functional programming concepts.
• Verbose: Can be more verbose compared to some traditional HTTP frameworks.
• Not a Full Framework: Unlike frameworks like Play or Spring, Akka HTTP is primarily a library, so additional setup may be required for larger projects.

val route =
  path("users" / IntNumber) { userId =>
    get {
      complete(getUser(userId))
    } ~
    put {
      entity(as[User]) { user =>
        complete(updateUser(userId, user))
      }
    }
  }

def getUser(userId: Int): Future[HttpResponse] = {
  // Interact with actor(s) to fetch data
}
def updateUser(userId: Int, user: User): Future[HttpResponse] = {
  // Interact with actor(s) to update data
}?

implicit val userFormat = jsonFormat3(User)
val jsonResponse = HttpResponse(entity = HttpEntity(ContentTypes.`application/json`, user.toJson.toString()))?

Http().newServerAt("localhost", 8080).bind(route)?

class CustomException(msg: String) extends RuntimeException(msg)

trait CustomExceptionHandler {
  implicit def myExceptionHandler: ExceptionHandler =
    ExceptionHandler {
      case e: CustomException =>
        extractUri { uri =>
          log.error(s"Request to $uri failed with ${e.getMessage}")
          complete(HttpResponse(StatusCodes.BadRequest, entity = e.getMessage))
        }
    }
}

object MyServer extends App with CustomExceptionHandler {
  val route = handleExceptions(myExceptionHandler) {
    path("example") {
      throw new CustomException("Custom error message")
    }
  }

  Http().bindAndHandle(route, "localhost", 8080)
}?

1. Architecture and Design Philosophy :

2. Routing :

Comparison Table: Akka HTTP vs. Play Framework :

The role of Akka Streams in Akka HTTP is fundamental, as Akka HTTP leverages Akka Streams to handle and process HTTP requests and responses in a reactive, non-blocking, and backpressure-aware manner. Here's an overview of its role:

1. Reactive Data Processing :

Akka HTTP relies on Akka Streams to manage the flow of data through HTTP connections. This ensures:

• Non-blocking behavior: Data is processed asynchronously without threads waiting for operations to complete.
• Backpressure support: When a consumer (e.g., a client) cannot process data quickly, Akka Streams ensures the producer (e.g., the server) slows down to avoid overwhelming the consumer.
•  

2. Handling HTTP Request/Response Entities :

HTTP entities (like request bodies and response payloads) are modeled as Akka Streams Source. This allows streaming large data efficiently:

• Request Entity: HttpRequest bodies are exposed as a Source[ByteString, Any], enabling streaming and processing large payloads without loading the entire content into memory.
• Response Entity: HttpResponse bodies can be constructed using a Source[ByteString, Any], allowing you to stream data directly to clients.

val route = path("stream") {
  get {
    val dataStream = Source(1 to 100).map(num => ByteString(s"$num\n"))
    complete(HttpResponse(entity = HttpEntity(ContentTypes.`text/plain(UTF-8)`, dataStream)))
  }
}?

3. Streaming WebSockets :

Akka Streams powers WebSocket support in Akka HTTP, allowing for bi-directional streaming communication between the server and clients. WebSocket messages are modeled as Akka Streams Flow objects, enabling real-time data exchange with backpressure handling.

Example :

val webSocketFlow: Flow[Message, Message, Any] = Flow[Message].map {
  case TextMessage.Strict(text) => TextMessage(s"Echo: $text")
  case _ => TextMessage("Unsupported message type")
}

val route = path("ws") {
  handleWebSocketMessages(webSocketFlow)
}

4. Composition of Directives :

Akka HTTP directives (e.g., mapAsync, entity, extractDataBytes) work seamlessly with Akka Streams to compose reactive pipelines for processing requests and responses.

Example :

val route = path("upload") {
  post {
    entity(asSourceOf[ByteString]) { byteSource =>
      val lineCountFuture = byteSource
        .via(Framing.delimiter(ByteString("\n"), maximumFrameLength = 256, allowTruncation = true))
        .runFold(0)((count, _) => count + 1)

      onSuccess(lineCountFuture) { lineCount =>
        complete(s"Uploaded file contains $lineCount lines")
      }
    }
  }
}

5. Efficient Connection Management :

Akka Streams provides efficient handling of TCP connections, which is vital for HTTP server and client operations:

• Manages concurrent connections without blocking.
• Ensures scalability by leveraging Akka’s actor model and stream processing.

6. Transformations and Pipelines :

With Akka Streams, you can apply transformations to the data as it flows through the HTTP pipeline:

• Filtering: Removing unwanted data.
• Mapping: Transforming data (e.g., decoding JSON or processing text).
• Aggregation: Combining multiple data elements into one (e.g., counting or reducing).

Akka Streams provides a declarative, compositional API for working with streaming data. Its integration into Akka HTTP makes it a powerful choice for:

1. Scalability: Handle a large number of concurrent requests.
2. Resource Efficiency: Avoid overloading resources with backpressure.
3. Streaming Applications: Ideal for real-time applications like data feeds, video/audio streaming, or analytics pipelines.

In Akka HTTP, routes define how incoming HTTP requests are handled by your application. A route maps an HTTP request (based on its method, URI, headers, or body) to a specific action, such as returning a response or invoking application logic. Routes form the backbone of an Akka HTTP application, enabling the definition of endpoints and their associated behavior.

Key Features of Routes :

1. Declarative DSL: Routes in Akka HTTP are defined using a concise, declarative Domain-Specific Language (DSL) provided by the library.

2. Composability: Routes can be combined hierarchically, allowing for reusable and modular definitions of complex routing logic.

3. Pattern Matching: Routes support pattern matching for HTTP methods (e.g., GET, POST), paths, query parameters, headers, and even request entities.

4. Integration with Directives: Akka HTTP provides powerful directives, which are building blocks used to create routes by defining how requests are processed.

Directives in Routes :

Routes rely on directives, which are composable building blocks used to define behavior. Examples include:

• path: Matches a specific URI path.
• get, post, etc.: Matches HTTP methods.
• parameter: Extracts query parameters.
• headerValueByName: Extracts headers.
• entity: Extracts and processes the request body.

In Akka HTTP, the path and pathPrefix directives are used to match and handle parts of the request URI. While both are involved in routing based on the path, they differ in how they match and handle the URI. Here's a detailed comparison:

1. path Directive :

The path directive is used to match exact path segments in the URI. It requires the entire remaining path to match exactly, with no additional segments allowed unless explicitly defined.

Key Characteristics:

• Matches the exact path specified.
• Does not allow additional segments after the match.
• Commonly used for specific, well-defined routes.

Example :

val route = path("users") {
  complete("Users endpoint")
}
?

2. pathPrefix Directive :

The pathPrefix directive is used to match the beginning (prefix) of a path. It allows additional segments in the URI after the matched prefix, which can be handled by nested routes.

Key Characteristics:

• Matches the specified prefix and allows the remaining path to be processed by child directives or routes.
• Ideal for grouping routes under a common base path.

Example :

val route = pathPrefix("users") {
  path("create") {
    complete("Create user")
  } ~
  path(IntNumber) { userId =>
    complete(s"Details for user $userId")
  }
}?

val jsonType = MediaType.applicationWithFixedCharset("custom-json", HttpCharsets.`UTF-8`)
val xmlType = MediaType.applicationWithFixedCharset("custom-xml", HttpCharsets.`UTF-8`)?

import akka.http.scaladsl.model._
import MediaTypes._
val imageData: Array[Byte] = ...
val contentType = if (request.header[headers.Accept].exists(_.mediaRanges.exists(_.matches(`image/jpeg`)))) {
  ContentType(`image/jpeg`)
} else {
  ContentType(`image/png`)
}
HttpResponse(entity = HttpEntity(contentType, imageData))?

akka.http.host-connection-pool {
  max-connections = 50
  min-connections = 10
  max-retries = 3
  idle-timeout = 30s
  pipelining-limit = 2
  response-entity-subscription-timeout = 15s
}?

class MyRoutesSpec extends WordSpec with Matchers with ScalatestRouteTest {
  val myRoutes = new MyRoutes().routes
  "MyRoutes" should {
    "return a greeting" in {
      Get("/greet") ~> myRoutes ~> check {
        responseAs[String] shouldEqual "Hello!"
      }
    }
  }
}?

class MyServerSpec extends WordSpec with Matchers with BeforeAndAfterAll {
  val server = new MyServer()
  implicit val system = ActorSystem("test-system")
  override def beforeAll(): Unit = server.start()
  override def afterAll(): Unit = server.stop()
  "MyServer" should {
    "return a greeting" in {
      Http().singleRequest(HttpRequest(uri = "http://localhost:8080/greet")).map { response =>
        response.status shouldEqual StatusCodes.OK
        Unmarshal(response.entity).to[String].map(_ shouldEqual "Hello!")
      }
    }
  }
}?

import akka.http.scaladsl.server.Directive1
import akka.http.scaladsl.server.directives._
def apiKeyValidation(apiKey: String): Directive1[String] = {
  val validApiKey = "my-secret-key"
  if (apiKey == validApiKey) provide(apiKey)
  else reject(AuthorizationFailedRejection)
}
val route =
  path("secure") {
    headerValueByName("api-key") { apiKey =>
      apiKeyValidation(apiKey) { _ =>
        complete("Authorized access")
      }
    }
  }?

import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._
import spray.json.DefaultJsonProtocol._
case class User(name: String, age: Int)
object UserJsonProtocol extends DefaultJsonProtocol {
  implicit val userFormat = jsonFormat2(User)
}
import UserJsonProtocol._
val route =
  path("users") {
    post {
      entity(as[User]) { user =>
        complete(user)
      }
    }
  }?

import akka.http.scaladsl.Http
import akka.http.scaladsl.model.StatusCodes
import akka.http.scaladsl.model.sse.ServerSentEvent
import akka.http.scaladsl.server.Directives._
import akka.stream.scaladsl.Source
val route =
  path("scores") {
    get {
      complete {
        HttpEntity(
          ContentTypes.`text/event-stream`,
          Source.fromPublisher(scoreUpdates)
            .map(ServerSentEvent(_))
            .keepAlive(1.second, () => ServerSentEvent.heartbeat)
        )
      }
    }
  }
Http().bindAndHandle(route, "localhost", 8080)?

FROM openjdk:8-jre
COPY target/scala-2.12/my-akka-http-app.jar /app/
CMD ["java", "-jar", "/app/my-akka-http-app.jar"]?

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-akka-http-app
spec:
  replicas: 3
  template:
    metadata:
      labels:
        app: my-akka-http-app
    spec:
      containers:
      - name: my-akka-http-app
        image: myregistry.com/my-akka-http-app
        ports:
        - containerPort: 8080?

apiVersion: v1
kind: Service
metadata:
  name: my-akka-http-app
spec:
  selector:
    app: my-akka-http-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
  type: LoadBalancer?

The complete directive in Akka HTTP is used to terminate the processing of a route and generate an HTTP response that is sent back to the client. It is a core directive that allows you to specify the content of the response, including the status code, headers, and the response entity (body).

Key Purposes of complete :

1. Send HTTP Responses

   • The complete directive provides a way to return a response to the client, whether it's a simple string, a JSON object, or a full HttpResponse object.

2. Terminate Route Handling

   • Once the complete directive is executed, no further processing is done for that route.

3. Flexible Response Generation

   • It supports a wide variety of response types, including plain strings, custom status codes, objects (like JSON), and even streamed responses.