Before we start, you must know about Dockers and Containers, working of containers and images, volumes, networking in containers, and multi-container apps.

Problem with Containers

Managing Docker containers can be challenging, especially in large-scale environments where you might have hundreds or thousands of containers running across multiple hosts and servers, which eventually are serving an application with millions of users. Some of the major challenges of managing Docker containers include:

1. Deployment: Deploying and updating Docker containers can be time-consuming, especially when you need to update multiple containers at once. Although we have Docker Compose to rescue us from this problem, we are talking about a large number of Containers.

2. Scaling: Scaling Docker containers can be difficult, especially if you need to scale up or down quickly in response to changes in demand. Scaling Docker containers can be challenging because it requires balancing the resources available on the host machine with the resource needs of the containers. Additionally, it can be difficult to determine the optimal number of containers to run in a production environment, as it depends on factors such as the resource requirements of the application, and the number of users accessing the application.

3. Load balancing: Distributing traffic across multiple Docker containers can be challenging, especially if you need to do it in a way that is both efficient and fault-tolerant. In addition, load balancing refers to the distribution of incoming traffic to multiple containers running on a single host or across multiple hosts. Load across all the containers should be distributed equally, which is a very rigorous task.

4. Monitoring: Monitoring the health and performance of Docker containers can be difficult, especially in large-scale environments where you might have hundreds or thousands of containers running. In case of an app crash, that particular needs to be replaced with a new container, which in turn is a challenging task.

   Although, we have cloud service providers like AWS which provides services like AWS ECS, which solves all these problems you are then limited to what these services provide. You have to follow the rules of these services, you will have to configure everything as defined by these services, which might not be a solution.

   In addition, if we have to switch to another cloud service provider, then we again have to rewrite the entire configuration for our apps that meet the rules of the new cloud service provider. So, these are the problems that Kubernetes solves and make the management of these containers much simpler.

   In case, if you are comfortable with these services, and your requirements meet with what these services provide, then it's okay to go with them.

   What is Kubernetes?

   Kubernetes is an open-source container orchestration system for automating the deployment, scaling, and management of containerized applications. I hope this official definition of Kubernetes, is now very easy to understand. It helps us in automatic deployment, scaling, load balancing and management of containers.

   In addition, Kubernetes is not a cloud service provider, not a service provided by a cloud service provider, it's not restricted to any service provider, not the software you run on some machine, not an alternative to Docker, and not a paid service.

   Kubernetes is an open-source project, it's a collection of objects and tools, that can be used with any cloud service provider, and work together with Dockers(Containers).

Architecture of Kubernetes

Before going further, we need to be very clear about What Kubernetes will do and don't. Following are the actions that as a user you need to do -

1. Create the cluster and the Node instances(Worker + Master Nodes).

2. Set up API Server, kubelet and other Kubernetes services or software on Nodes.

3. Create other cloud provider resources that might be needed (e.g Load Balancer and File Systems.)

The following are the actions that Kubernetes will perform -

1. Create your objects (e.g Pods and Deployments) and manage them.

2. Monitor Pods and re-create them, scale pods, destroy them etc

3. Kubernetes utilizes the provided cloud resources to apply your configuration and goals.

We can also think of Kubernetes is like Docker Compose for multiple machines, it's a simple analogy! But not just it.

Core Components of Kubernetes Ecosystem

1. Cluster - A set of Node machines that are running the Containerized Applications(in Worker Nodes) or other Nodes(Master Node).

2. Nodes - It is a physical or virtual machine with a certain hardware capacity that hosts one or multiple Pods and communicates with other cluster resources.

3. Master Node - It contains Cluster Control Plane, managing the Pods across the Worker Nodes.

4. Worker Node - It hosts Pods, running App Containers and their required resources.

5. Pods - Pods hold the actual running App Containers and their required resources (e.g Volumes)

6. Containers - These are normal Docker Containers.

7. Services - A logical set of Pods with a unique, Pod and Container independent IP Address.

Conclusion

Kubernetes is an open-source container orchestration system for automating the deployment, scaling, and management of containerized applications. We understood what problems arise with Containers, What Kubernetes solves, and How it solves them. Problems like auto-scaling, load balancing and monitoring are solved by Kubernetes. Kubernetes is an open-source project, it's a collection of objects and tools, that can be used with any cloud service provider.

I hope from this article, you are very clear about the core concepts of Kubernetes, its terminologies and the architecture of Kubernetes. In the future articles, we will understand this by creating a cluster and running them on local machines then, all these concepts will be more clear.

Thank You!

In this article, we are going to learn about routing in Flutter, how we can navigate from one screen to another, with custom arguments, simple clean and reusable code, in structured format

I am assuming you already know basics of Flutter (create simple widgets, functions and classes.). We are specifically going to see how to use named routes, and learn how to use them in managing routes easily!

Below is the GitHub link, you can follow each step using this repository.

https://github.com/Sarthak-ONS/simple-routing.git

After removing the initial written code by Flutter, lets start.

import 'package:flutter/material.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({Key? key}) : super(key: key);

  // This widget is the root of your application.
  @override
  Widget build(BuildContext context) {
    return const MaterialApp(
      debugShowCheckedModeBanner: false,
      title: 'Flutter Demo',
      home: Text("Learn Routing"),
    );
  }
}

Lets us make three simple different screen and learn routing from them. Create a new Folder and add three separate files for three screens respectively.

Note: you can name these files as per your choice

We are going to make a button widget and put it in a separate file, this button widget is used for navigating to different screens.

This button widget takes two parameters- 1. Title of Button 2. On tap Callback.

Lets make this button widget

import 'package:flutter/material.dart';

class MyCustomButton extends StatelessWidget {
  const MyCustomButton({
    Key? key,
    required this.title,
    required this.onTapFunction,
  }) : super(key: key);

  final String title;
  final Function onTapFunction;

  @override
  Widget build(BuildContext context) {
    return GestureDetector(
      onTap: () {
        onTapFunction();
      },
      child: Center(
        child: Container(
          margin: const EdgeInsets.symmetric(vertical: 10, horizontal: 20.0),
          padding: const EdgeInsets.symmetric(vertical: 10, horizontal: 20.0),
          decoration: const BoxDecoration(
            color: Color(0xff263F59),
            borderRadius: BorderRadius.all(
              Radius.circular(15.0),
            ),
          ),
          child: Text(
            title,
            style: const TextStyle(
              color: Colors.white,
              fontSize: 20,
            ),
          ),
        ),
      ),
    );
  }
}

Lets now make our first screen with basic widgets like App Bar and two custom built button at the center of the screens.

import 'package:flutter/material.dart';

import '../custom_button_widget.dart';

class Screen1 extends StatelessWidget {
  const Screen1({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        centerTitle: true,
        backgroundColor: const Color(0xff263F59),
        title: const Text('First Screen'),
      ),
      body: Column(
        mainAxisAlignment: MainAxisAlignment.center,
        children: [
          MyCustomButton(
            onTapFunction: () {
              print("Navigate to Screen 2");
            },
            title: "Screen 2",
          ),
          MyCustomButton(
            onTapFunction: () {
             print("Navigate to Screen 3");
            },
            title: "Screen 3",
          ),
        ],
      ),
    );
  }
}

Now, our first Screen looks like this -

Similarly we will make our second and third screen.

Note : Please change title of App Bar and Custom Buttons accordingly to avoid any errors.

Please, check the source code on GitHub for any kinds of errors and problems.

Now, we will create a Route Generator File and add all our route in in it. Lets see how we can do it.

First create a new file, then add a Route Generator Class and add two methods in it, First method, will return a Material Page Route to a specific Screen and second method will return a error Screen, if in case there occurs any error we can return that screen.

We are using named route, using Route Settings we can get the name of each called route.

Note : We are repeating code for now, but in later section we will remove this repeating code

import 'package:flutter/material.dart';

import 'package:simple_routing/Screens/screen_one.dart';
import 'package:simple_routing/Screens/screen_two.dart';
import 'package:simple_routing/Screens/screen_third.dart';

class RouteGenerator {

  Route<dynamic> generateRoute(RouteSettings routeSettings) {
    switch (routeSettings.name) {
      case '/':
        return MaterialPageRoute(builder: (_) => const Screen1());
      case '/second':
        return MaterialPageRoute(builder: (_) => const Screen2());
      case '/third':
        return MaterialPageRoute(builder: (_) => const Screen3());
      default:
        return _errorRoute();
    }
  }

  static Route<dynamic> _errorRoute() {
    return MaterialPageRoute(
      builder: (_) => Scaffold(
        appBar: AppBar(
          title: const Text('Error'),
        ),
        body: const Center(
          child: Text('Please try again later'),
        ),
      ),
    );
  }
}

Now, we will add this generateRoute Method to our material App widget in main.dart file. We will remove "home" parameter in Material App and pass a initial Screen Route to "initialRoute" parameter, we will give '/' as a initialRoute parameter's value, which corresponds to First Screen in our generateRoute Method of Route Generator Class.

import 'package:flutter/material.dart';
import 'package:simple_routing/route_generator.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({Key? key}) : super(key: key);

  // This widget is the root of your application.
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      debugShowCheckedModeBanner: false,
      initialRoute: '/',
      onGenerateRoute: RouteGenerator().generateRoute,
    );
  }
}

Lets, start navigating using Route generator class. Now, go to screen1, and in onTapCallback of Screen2's button, navigate to screen2. Similarly, on tapCallback of Screen3's button, navigate to Screen3. We are going to use Navigator.pushNamed() method to navigate between screens.

MyCustomButton(
        onTapFunction: () {
              Navigator.pushNamed(context, '/second');
         },
        title: "Screen 2",
  ),
MyCustomButton(
          onTapFunction: () {
              Navigator.pushNamed(context, '/third');
          },
         title: "Screen 3",
  ),

Now, you may add named route in callbacks of buttons of Screen2 and Screen3 respectively.

Note: On using Navigator.pushNamed() method, screens are added to the stack, it means next screen are added to top of current screen, You can use Navigator.popAndPushNamed() to remove current screen from stack and then push to next screen.

I hope you will now be able to route between different screens!.

We can also check error Route, passing wrong arguments in Navigator.pushNamed() method, or not passing any value in method that does not corresponds to mentioned names in Route generator Class.

Lastly, we can also avoid using the "MaterialPageRoute(builder: (_) => const Screen1())" again and again in Route Generator Class by making a new method, that takes a widget in in its parameter and returns a Material Page Route.

import 'package:flutter/material.dart';

import 'package:simple_routing/Screens/screen_one.dart';
import 'package:simple_routing/Screens/screen_two.dart';
import 'package:simple_routing/Screens/screen_third.dart';

class RouteGenerator {
  Route<dynamic> generateRoute(RouteSettings routeSettings) {
    switch (routeSettings.name) {
      case '/':
        return getMaterialPageRoute(const Screen1());
      case '/second':
        return getMaterialPageRoute(const Screen2());
      case '/third':
        return getMaterialPageRoute(const Screen3());
      default:
        return _errorRoute();
    }
  }

  static Route<dynamic> _errorRoute() {
    return MaterialPageRoute(
      builder: (_) => Scaffold(
        appBar: AppBar(
          title: const Text('Error'),
        ),
        body: const Center(
          child: Text('Please try again later'),
        ),
      ),
    );
  }

  MaterialPageRoute getMaterialPageRoute(Widget widget) {
    return MaterialPageRoute(builder: (_) => widget);
  }
}

Thus we can avoid repeating code, increase code reusability. We don't have to use "Navigator.push(context, MaterialPageRoute(builder: (context) =>widget()),);" route Function again and again and avoid import screens in each file. Our code looks clean and way better now.

Please check the GitHub repository for complete code.

I hope this article have created some help for you! Please share it with other developers