DEV Community: harrissolangi

An introduction to Kubernetes, the open-source container orchestration system developed by Google

harrissolangi — Tue, 17 Jan 2023 13:24:48 +0000

Kubernetes is an open-source container orchestration system that was developed by Google. It can be used to manage containerized applications across a cluster of machines. It automates the deployment, scaling, and management of containerized applications.

To use Kubernetes on Google Cloud, you can use Google Kubernetes Engine (GKE) which allows you to easily create and manage a Kubernetes cluster on Google Cloud.

An example of how to use Kubernetes to manage a Java application on Google Cloud would be to first package your Java application in a Docker container.
You can use a Dockerfile to create the container image, for example:

FROM openjdk:8
COPY . /app
WORKDIR /app
RUN javac Main.java
CMD ["java", "Main"]

You can then create a Kubernetes Deployment to manage the containerized application, for example:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-java-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-java-app
  template:
    metadata:
      labels:
        app: my-java-app
    spec:
      containers:
      - name: my-java-app
        image: gcr.io/my-project/my-java-app:v1
        ports:
        - containerPort: 8080

and a Service to define how the application can be accessed, for example:

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

You can also use Kubernetes ConfigMap and Secrets to manage application configuration and secrets separately from your application code, as well as use Kubernetes resource like pod, service and replica set to control how your application is deployed and scaled.

You can use command-line tools such as 'kubectl' to interact with your Kubernetes cluster and deploy your application.

kubectl apply -f deployment.yml kubectl apply -f service.yml

Please note that the above code examples are just a simple demonstration of how to use Kubernetes on GCP with a Java application, and a complete implementation will likely require additional configuration and resources.

Creating a basic GET API with Firebase Cloud Functions and Firestore

harrissolangi — Wed, 11 Jan 2023 09:57:16 +0000

Creating a GET API that fetches 100 records using Firebase Cloud Functions and Firestore is relatively simple. Here's an example of how to do it:

Start by creating a new Firebase Cloud Function and selecting an HTTP trigger.
In the function's index.js file, import the Firebase and Firestore modules by adding the following lines at the top:

const functions = require('firebase-functions'); const admin = require('firebase-admin'); admin.initializeApp(); const db = admin.firestore();

Then in the function's body you can use the get() method from the firestore collection object with the limit() method that sets the maximum number of documents to retrieve, in this case, you want to get 100 documents.

exports.get100Records = functions.https.onRequest((req, res) => { db.collection("collection_name") .limit(100) .get() .then(snapshot => { const data = []; snapshot.forEach(doc => { data.push(doc.data()); }); res.json(data); }) .catch(error => { res.status(500).send(error); }); });

Once your function is ready, you will want to deploy it to Firebase. This can be done by running the following command in your command line: firebase deploy --only functions
Now you can test the API endpoint by sending a GET request to the endpoint and checking the results.

Note that this is a simplified example.

Another slightly complex example is shared below :

`const functions = require('firebase-functions');
const admin = require('firebase-admin');
admin.initializeApp();
const db = admin.firestore();

exports.get100Records = functions.https.onRequest((req, res) => {
// Get request parameters
const { orderBy, orderDirection, filterBy } = req.query;

// Create a reference to the Firestore collection
let collectionRef = db.collection('collection_name');

// Apply sorting if specified
if (orderBy && orderDirection) {
    collectionRef = collectionRef.orderBy(orderBy, orderDirection);
}

// Apply filtering if specified
if (filterBy) {
    collectionRef = collectionRef.where(filterBy.field, filterBy.op, filterBy.value);
}

// Get the first 100 documents
collectionRef.limit(100).get()
.then(snapshot => {
    const data = [];
    snapshot.forEach(doc => {
        data.push(doc.data());
    });
    res.json(data);
})
.catch(error => {
    console.log(error);
    res.status(500).send(error);
});

});
`

In this example, the API endpoint accepts query parameters for sorting (orderBy and orderDirection) and filtering (filterBy) the data before fetching the first 100 records.

You can test this endpoint by sending a GET request to the endpoint with the appropriate query parameters.

Create APIs with Firebase

harrissolangi — Wed, 11 Jan 2023 09:50:20 +0000

Go to the Firebase console (https://console.firebase.google.com/) and create a new project.
Once you have created your project, navigate to the "Database" section in the left sidebar and click on the "Realtime Database" tab.
Click on the "Create database" button and choose "Start in test mode" to allow anyone to read and write to your database.
To connect to the Firebase Realtime Database from your Java application, you will need to install the Firebase SDK using Maven or Gradle, and include it in your code. Here's an example of how to do this in Java:

// Import the Firebase SDK
import com.google.firebase.*;
import com.google.firebase.database.*;

// Initialize Firebase
FirebaseOptions options = new FirebaseOptions.Builder()
  .setApiKey("your_api_key")
  .setAuthDomain("your_auth_domain")
  .setDatabaseUrl("your_database_url")
  .setProjectId("your_project_id")
  .setStorageBucket("your_storage_bucket")
  .setMessagingSenderId("your_messaging_sender_id")
  .build();
FirebaseApp.initializeApp(options);

Create the API endpoint(s) for your application. For example, here's a simple endpoint for creating a new record in the database:

app.post("/create", new Route() {
    @Override
    public Object handle(Request request, Response response) {
        // Get the new record from the request body
        Map<String, String> newRecord = new Gson().fromJson(request.body(), Map.class);

        // Get a reference to the database
        DatabaseReference ref = FirebaseDatabase.getInstance().getReference();

        // Push the new record to the database
        ref.push().setValue(newRecord);

        // Send a response
        response.status(200);
        return "Record created successfully.";
    }
});

To deploy your API, you can use a hosting service such as Firebase Hosting or any other service that supports Java.
Finally, you can test your API using a tool such as Postman or curl.

Please note that this is a basic example, it is recommended to also secure your API with Firebase Authentication and Firebase Cloud Firestore Security Rules.
You can find more detailed information and sample code in the Firebase Realtime Database documentation for Java: https://firebase.google.com/docs/database/admin/start

Also, you can use Firebase Admin SDK for Java to interact with Firebase Realtime Database, it has more functionalities like authentication, and security rules checking. https://firebase.google.com/docs/admin/setup.