DEV Community: Espoir Murhabazi

Batch Vector Search with PgVector and PostgreSQL Using Cross Lateral Joins

Espoir Murhabazi — Mon, 15 Sep 2025 00:00:00 +0000

Last week, while working on a project, I needed to perform a batch vector search in Postgres—sending multiple embedding vectors at once to avoid using a for-loop.

I started googling online and found an old answer on StackOverflow using a query with UNIONs. When I asked Deepseek how to improve the query, it recommended I use a CROSS JOIN LATERAL, which seemed to be faster than a normal union.

Then I started digging a little bit deeper to understand what cross lateral joins are. Unfortunately, I couldn’t find any blog online that was explaining them in the context of a vector database, which is why I decided to put this guide together.

The problem

Let’s say you have a list of questions and you need to perform an embedding search for all of them at once. This can happen when you need to evaluate how an embedding model performs on a set of queries. For each query, you want to retrieve the top 10 relevant chunks. In this post, we will work with a document table of this form for simplicity:

document
--
doc_id: int
embedding: vector(1024)
content: Text

Recap on Similarity Search

You have a query text that has been embedded into a vector using an embedding model. You want to query your vector database to retrieve similar text to your query using the embedding and cosine similarity as a distance measure.

Here is how you will perform the query using Postgres with the pgvector extension installed. You would perform something along these lines:

SELECT (1 - ("embedding" <=> %(query_embedding)s::vector)) as similarity, "content", "url" FROM "documents" ORDER BY similarity desc LIMIT 5

If you have been working with RAG, that query is familiar to you.

Different Approaches to Solve the Problem:

Similarity search with multiple queries

Assuming now that you have 100 or 1000 queries that you want to send to the database and for each query you want to retrieve the corresponding documents.

A naive Python code would look like this:

query = """SELECT (1 - ("embedding" <=> %({query_embedding})s::vector)) as similarity, "content", "url" FROM "documents" ORDER BY similarity desc LIMIT 5"""

for question_embedding in embeddings:
    db_client.execute(query, embedding=question_embedding)

With this approach, you can see for each question you will be performing a round trip to the database and retrieve the results. If your database is hosted in a remote server that round trip can be costly for the performance of your application.

That can be inefficient when you are dealing with hundreds or thousands of vectors. This is why I started thinking that there could be a better way to do this.

First Improvement: The UNION ALL Approach

One way that came to my mind was to use the union query. With the union query, our query will look like this.

(SELECT (1 - ("embedding" <=> %({query_embedding_1})s::vector)) as similarity, "content", "url" FROM "documents" ORDER BY similarity desc LIMIT 5)
UNION ALL
(SELECT (1 - ("embedding" <=> %({query_embedding_2})s::vector)) as similarity, "content", "url" FROM "documents" ORDER BY similarity desc LIMIT 5)
.
.
.
...
UNION ALL
(SELECT (1 - ("embedding" <=> %({query_embedding_n})s::vector)) as similarity, "content", "url" FROM "documents" ORDER BY similarity desc LIMIT 5)

A Python code to generate that query would be something like this:

base_query = """SELECT (1 - ("embedding" <=> %(query_embedding_{index})s::vector)) as similarity, "content", "url" FROM "documents" ORDER BY similarity desc LIMIT 5"""
all_queries = []
for i in range(embeddings.shape[0]):
    formatted_query = base_query.format(index=i)
    all_queries.append(formatted_query)

final_query = " UNION ALL ".join(all_queries)

# then you execute using
db.execute(final_query, embeddings.tolist())

This will give better performance than the previous one, but there is still room for improvement. And that is when the cross lateral join comes in.

The Superior Solution: Cross Join Lateral

Cross lateral join

Before diving deep into the SQL aspect of cross lateral join, let’s recap a concept from high school algebra.

Cartesian Product

The Cartesian product of two sets A and B, written A x B, is the set of all ordered pairs in which the first element belongs to A and the second belongs to B:

\times B = {(a, b) \mid a \in A \text{ and } b \in B}

Let’s assume we have

A = {1, 2, 3}

and

B = {A, B, C}

, the Cartesian product of (A) and (B) will be the following:

\times B = {(1,A), (1, B), (1,C), (2,A), (2, B), (2,C), (3,A), (3, B), (3,C)}

We can also note that the cardinality of A x B = |A| x |B|. In our example, we will have the cardinality equal to nine.

From Cartesian Product to Cross Join

With the Cartesian product in mind, let’s define the cross join:

The CROSS JOIN is used to generate a paired combination of each row of the first table with each row of the second table.

Here is an example of two tables and the resulting table from a cross join:

Cross Join in SQL

It was taken from this site.

Here is the syntax of the cross join. Given two tables Meals and Drinks:

SELECT Meals.name, Drinks.Name FROM Meals
CROSS JOIN Drinks

On To Cross Lateral Join

What if we found a way to do better? As we have a list of vectors, how can we run the select against each vector in the list of vectors? This is where cross lateral join comes in handy.

In the Postgres documentation, here is what is said about that query:

LATERAL:

The LATERAL key word can precede a sub-SELECT FROM item. This allows the sub-SELECT to refer to columns of FROM items that appear before it in the FROM list. (Without LATERAL, each sub-SELECT is evaluated independently and so cannot cross-reference any other FROM item.)

That is a little bit convoluted and hard to explain.

Let’s see how it works.

The Query:

SELECT
  results.*,
  vector_table.idx as query_index
FROM
  unnest(
    ARRAY[%(vector_0)s::vector, %(vector_1)s::vector, %(vector_2)s::vector]
  ) WITH ORDINALITY AS vector_table(query_vector, idx)
CROSS JOIN LATERAL (
    SELECT
      (1 - ("embedding" <=> vector_table.query_vector)) as similarity,
      "content",
      "url"
    FROM
      "documents"
    ORDER BY
      similarity desc
    LIMIT 5
  ) AS results
ORDER BY vector_table.idx, results.similarity DESC

Deconstructing the Magic Query

Let’s now dissect the query and see how it works. It has two parts.

Let’s look at the first one. The left part:

  unnest(
    ARRAY[%(vector_0)s::vector, %(vector_1)s::vector, %(vector_2)s::vector]
  ) WITH ORDINALITY AS vector_table(query_vector, idx)

This part is the temporary table creation where a table is created and has each embedding vector as a row. So our table will have:

1, vector_0
2, vector_1
3, vector_2
...
n, vector_n

The ordinality keyword adds an index starting from 1 to each row in the returned value of the first part.

Then the second part is a cross join. The table on the left is cross-joined with the table on the right. The LATERAL keyword helps to use the left table in the cross join clause. Without it, each sub-SELECT is evaluated independently and so cannot cross-reference any other FROM item.

That is why in the second item, we were able to reference the results of the first select as vector_table.query_vector.

The subquery is:

    SELECT
      (1 - ("embedding" <=> vector_table.query_vector)) as similarity,
      "content",
      "url"
    FROM
      "documents"
    ORDER BY
      similarity desc
    LIMIT 5

The documentation explains the execution perfectly:

When a FROM item contains LATERAL cross-references, evaluation proceeds as follows: for each row of the FROM item providing the cross-referenced column(s)… the LATERAL item is evaluated using that row or row set’s values of the columns. The resulting row(s) are joined as usual with the rows they were computed from. This is repeated for each row or set of rows from the column source table(s).

Benchmarks

Let us benchmark the 3 approaches and find out which one is the fastest.

We are running the query in a small setting where we have around 10k documents in our database each document has string content and embedding vector of size 1024. The database table is indexed on the embedding column using a hnsw index. The database and the code where both running on my local machine a Mac M1 with 16GB of CPU.

Later I will benchmark the three queries in a setting where the code run on a different machine than the database and I will update this section with the performance of the code in those settings.

After benchmarking and performing an analyzis on the answer with my table I found a small gain of performance on a small table.

In the upcoming version of this blog I replicate the setting in a table of millions documents and vector and report the performance.

Conclusion

In this post we explained how cross lateral join works with PGVectors. In the next post I will run a benchmark of the cross lateral and compare it with. a normal for loop for batch vector search.

[Boost]

Espoir Murhabazi — Mon, 26 May 2025 15:01:40 +0000

Espoir Murhabazi

May 26 '25

Evaluation Metrics for Summarization

#summarization #evaluation #ai #nlp

Comments

6 min read

Evaluation Metrics for Summarization

Espoir Murhabazi — Thu, 22 May 2025 00:00:00 +0000

Everyone wants GenAI, but no one wants to spend time on evaluation or generating reference texts.

I worked on a summarization project recently, but I have never spent time evaluating the summarization output. My summarizer balobi.info makes a lot of mistakes: sometimes it generates news in English, other times it confuses Congo and Rwanda, or sometimes it makes up stuff. Those errors could have been avoided if I had spent time evaluating the metrics and deciding which metrics I could use for my model.

Recently, I documented myself on summarization metrics, and I found a load of them online. I decided to summarize them for the reader in this post.

Definition

Text summarization is the process of producing a concise and coherent summary while preserving key information and meaning of the source text. There are two major approaches to automatic text summarization: extractive and abstractive summarization. _ Extractive summarization_ involves selecting important sentences or phrases from the original document. On the other hand, abstractive summarization generates the summary with sentences that are different from those in the original text while not changing the ideas. In most cases, when you prompt a Large Language Model (LLM), it generates an abstractive summary of the text.

Evaluation

Evaluation is the process of evaluating the quality of a summarization output. Evaluation of a summarization can be done in two ways: by using a human evaluator or using automated metrics._Human evaluation is more accurate but it is time-consuming and requires a lot of effort._Automatic evaluation is simple, easy to scale, but sometimes less accurate.

Human Evaluation:

In most cases, humans are tasked to evaluate the model outputs using four criteria:

Coherence : It evaluates how good the sentences are.
Consistency : The factual alignment between the summary and the summarized source. A factually consistent summary contains only statements that are entailed by the source document. Annotators were also asked to penalize summaries that contained hallucinated facts.
Fluency : The quality of individual sentences. Drawing again from the DUC quality guidelines, sentences in the summary ‘‘should have no formatting problems, capitalization errors or obviously ungrammatical sentences (e.g., fragments, missing components) that make the text difficult to read.’’
Relevance : Selection of important content from the source. The summary should include only important information from the source document. Annotators were instructed to penalize summaries that contained redundancies and excess information.

A final score is computed by averaging the scores of all these criteria.

Automatic Evaluation:

In term of automatic evaluation we have two types of metrics, references based metrics and non reference metrics. or references free metrics.

References metrics involves a human annotator who will give a reference summary to compare the generated summary against. For non references metrics there is no references and the generated summary is compared against the original text.

Metrics for References Evaluation:

reference based summary

Here are the metrics for automated summarization evaluation:

ROUGE: (Recall-Oriented Understudy for Gisting Evaluation), measures the number of overlapping textual units (n-grams, word sequences) between the generated summary and a set of gold reference summaries. Many papers have suggested that ROUGE metrics is the one that correlates the most with human juggement.
ROUGE-WE: extends ROUGE by using soft lexical matching based on the cosine similarity of Word2Vec embeddings.
BertScore: computes the semantic similarity scores by aligning generated and reference summaries on a token-level. Token alignments are computed greedily to maximize the cosine similarity between contextualized token embeddings from BERT.
BLEU: is a corpus level precision-focused metric that calculates n-gram overlap between a candidate and reference utterance and includes a brevity penalty. It is the primary evaluation metric for machine translation. CIDER: computes {1–4}-gram cooccurrences between the candidate and reference texts, down weighting common n-grams and calculating cosine similarity between the n-grams of the candidate and reference texts.

Reference Free Metrics:

Reference free summaries

Reference-free metrics are metrics that are based on the matching between the generated summary and the original document.

They are faster to implement as they don’t require any human annotator.

All the methods of reference metrics can be used to build reference-free metrics. We can do that by considering the original document as the summary and comparing the generated summary with it.

ROUGE-C : is a modification to ROUGE: Instead of comparing to a reference summary, the generated summary is compared to the source document. We can go further with ROUGE-C and create metrics that will down-weight common terms in the text. Up-weight important terms that are present in the summary.Researchers found that ROUGE-C correlated well with methods that depend on reference summaries, including human judgments.
SUPERT : Rate the quality of a summary by measuring it semantic similarity with a pseudo reference summary. The pseudo references are generated by selecting salient sentences from the source document using contextualized embedding and soft token alignment techniques. Compared to the state-of-the-art unsupervised evaluation metrics, SUPERT correlates better with human ratings by 18- 39%.
Entailment Metrics Based on NLI Tasks

Entailment metrics are based on the natural language inference (NLI) task where a hypothesis sentence is classified as entailed by, neutral, or contradicting a premise sentence. To evaluate abstractive summarization for consistency, we check if the summary is entailed by the source document. In the scientific literature the metric used is called SummaC.

How does SummaC works?

It split the original document in block of text(sentences, or paragraph), the generated summary by the sentences. Then use a NLI model such as BERT to compute the entailment score for each sentence of generated summary vs each sentence in the original document. Those scores are saved in a matrix which is called entailment matrix. For SummaCZS, they reduce the entailment matrix into a one-dimensional vector by taking the maximum value in each column. Intuitively, this results in retaining the score for the document sentence that provides the strongest support for each summary sentence. Then, to get a single score for the entire summary, they simply compute the mean of the vector. There are other sophisticated approaches of the entailment matrix using a convolutional layer. The bellow picture describes how the entailment matrix works.

SummaC summarization

LLM as a Judge for summaries Evaluation

With the rise of LLM, we have seen case in the literature where we are using LLM as a judge to evaluate the LLM summary. With this approach we let the LLM is trying to replicate the work a human evaluator.

Evaluating using a Language Model

Unlike metrics like ROUGE or BERTScore that rely on comparison to reference summaries, the gpt-4 based evaluator assesses the quality of generated content based solely on the input prompt and text, without any ground truth references. This makes it applicable to new datasets and tasks where human references are not available.

Here’s an overview of this method:

Using the four criteria used by human, coherence, consistency, fluency, and relevance.
Create a prompt that will ask the LLM to generate a score form 1 to 5 for each of those criteria using chain of thought generation.
We generate scores from the language model with the defined prompts, comparing them across summaries.

Note that LLM-based metrics could have a bias towards preferring LLM-generated texts over human-written texts. Additionally LLM based metrics are sensitive to system messages/prompts. Sometimes you don’t have an LLM available for evaluation and you need to stick to traditional metrics.

Conclusion

In this post, we highlight evaluation methods for summarization, discuss the different types of summarization evaluation, and show the pros and cons of each method. The right metrics for your summarization project depend on the engagement of your stakeholders. When they are engaged, ask them for reference summaries and fine-tune your prompts to obtain good metrics using the reference texts. Alternatively, you can ask them to evaluate different summaries generated by various prompts and different LLMs. If there is no engagement from the stakeholders from the beginning, prefer reference-free metrics.

Sources:

Liu Y, Iter D, Xu Y, Wang S, Xu R, Zhu C. (2023). G-EVAL: NLG Evaluation Using GPT-4 with Better Human Alignment.
Zhang T, Kishore V, Wu F, Weinberger KQ, Artzi Y. (2020). BERTScore: Evaluating Text Generation with BERT.
Lin CY. (2004). ROUGE: A Package for Automatic Evaluation of Summaries.
Fabbri A, et al. (2021). SummEval: Re-evaluating Summarization Evaluation.
Yan, Ziyou. (2023). Evaluation & Hallucination Detection for Abstractive Summaries.
He T, et al. (2008). ROUGE-C: A fully automated evaluation method for multi-document summarization. 2008 IEEE International Conference on Granular Computing, Hangzhou, China, pp. 269-274. doi: 10.1109/GRC.2008.4664680.
Natural Language Inference with Sentence Transformer.

Deploy your language models to production using the ONNX runtime and the Triton inference server

Espoir Murhabazi — Sun, 07 Apr 2024 22:12:57 +0000

Cover: Lac Kivu in East DRC

You are a Data Scientist who has finally trained a language model and it works in a jupyter notebook and you are happy with your results. Now you want to expose it to the users so that they can interact with it.

You have different options to serve your model to your users. You can use the jupyter notebook directly in production 🤣. You can wrap the model in a pickle file and serve it using an API 🤪. Both options work, but can they handle millions of requests per second in a production environment? In this post, I will show how you can use modern tools to deploy a language model in a scalable way. We will use the ONNX runtime, Triton inference server, Docker, and Kubernetes. These tools will help us to deploy a production-ready language model.

This guide is addressed to Data scientists, Machine Learning Engineers and researchers aiming to use their Language Models in Production. It discusses the engineering principles of scalable language models APIs.

It will be divided into multiple parts. In the first part, we will prepare the model for a production setting. We will use the ONNX runtime and Docker container to achieve that goal. Finally, in the second part, we will learn how to scale our Apis using Kubernetes.

If I have time later, I’ll explain how to use the embedding API in a downstream app like a Retrieval Augmentation Generation (RAG).

Before we dive into the deployment bits of this application, let us first review some theories about language models.

We will be deploying an embedding model, so let's start by defining a language model.

Mountain Gorilla, one of our similar cousins.

Embeddings.

Embedding models are the backbone of generative AI, they are representations of words in a vector space. They capture word semantics such as, with them similar vectors represent similar words.

Contextual embeddings are embeddings such as each word is represented with a vector given its context.

Let’s look at those two examples:

The bank of the river Thames is located in South London.

I am going to withdraw cash at Lloyds Bank.

In those two sentences the word bank has two different meanings. In the first, bank means the land alongside or sloping down to a river or lake. In the second sentence, it means a place where you save money.

Embedding models can capture those differences and represent words with two different vectors according to the context.

This is not a post to explain how embedding models are built, if you want to learn more about them refer to this post.

But one thing to know is that embedding models are built with language models or Large language models for the majority of cases.

Words Representation in 2D vector Space.

Large Language Model.

Large language models are neural networks or probabilistic models that can predict the next word given the previous words.

One of the most common neural network architectures that power language models is the Transformer model. It was introduced in 2017 by Google researchers. Those models have a powerful capacity when it comes to understanding words and their meanings because they are trained on a large corpus of documents.

During their training, transformers’ models can learn contextual word embeddings. Those embeddings are useful in downstream applications such as chatbots, document classification, topic modeling, document clustering et consort.

Again, this post is not about language models, there are legions on the internet, my favorite one is the illustrated trasnfomer.

If this post is not about word embedding theory, or large language model theory what is it about?

Nice question, this post is about deploying a large language model. We assume that you have a model trained on how you want to deploy it. We will learn how to create an embedding service, an API that developers can query to generate document embeddings.

We will build a scalable API that developers can query it to get word embeddings of their sentences. They can use the embeddings in downstream applications. This API can be part of a chatbot, or a Retrieval Augmented Generation application.

I made it for educational purposes while learning how to deploy a language model using Kubernetes. If you want a production-ready application that can support multiple embedding models check out this repository.

Enough talking let’s show us the code!

The embedding models.

In this post, we will explore the embedding model generated by the BioLinkBert. The BioLinkBert model is a model from the BERT family but it was fine-tuned on documents from the medical domain. The reason I used the Biolink model is that I wanted to build a chatbot application for the medical domain in the future.

The embedding of words is the last hidden state of a transformer model where the input is the word encoded as text. Let us see how it works in practice. We will be using a custom Bert model which inherits the base Bert model from Huggingface.

import torch
from dataclasses import dataclass
from typing import Optional, Mapping, OrderedDict
from transformers.onnx import OnnxConfig
from transformers.utils import ModelOutput
from transformers import BertModel

@dataclass
class EmbeddingOutput(ModelOutput):
    last_hidden_state: Optional[torch.FloatTensor] = None

class CustomEmbeddingBertModel(BertModel):
    def forward(
        self,
        input_ids: Optional[torch.Tensor] = None,
        attention_mask: Optional[torch.Tensor] = None,
        head_mask: Optional[torch.Tensor] = None,
        inputs_embeds: Optional[torch.Tensor] = None,
    ) -> EmbeddingOutput:
        embeddings = super().forward(input_ids=input_ids,
                                     attention_mask=attention_mask,
                                     head_mask=head_mask,
                                     inputs_embeds=inputs_embeds,
                                     output_attentions=True,
                                     output_hidden_states=True,
                                     return_dict=True)
        mean_embedding = embeddings.last_hidden_state.mean(dim=1)
        embedding_output = EmbeddingOutput(last_hidden_state=mean_embedding)
        return embedding_output

Our custom embedding is a wrapper around the Bert embedding model. It takes the input ids and returns the embedding of a sentence. The input IDs are the tokenized version of a sentence. The embeddings of the sentence are the average of the embedding of all words in a sentence.

Here is how that works in practice.

embedding_model_id = 'michiyasunaga/BioLinkBERT-large'
base_model = CustomEmbeddingBertModel.from_pretrained(embedding_model_id)

Before passing the text to the embedding, it needs to be transformed in a tokenizer.

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained(embedding_model_id)

test_input = f"What is the cause of Covid"
encoded_input = tokenizer([test_input],
                          return_tensors='pt',
                          max_length=512,
                          truncation=True,)

With our encoded_input and the base model, we can generate the text embedding for our text input.

encoded_input


encoded_input.pop('token_type_ids')


embedding_output = base_model(**encoded_input)
text_embeddings = embedding_output.last_hidden_state.detach().numpy().reshape(-1)
print(text_embeddings.shape)

The text embedding is the embedding representation of the sentence in text_input. It can be used in downstream applications in different ways.

The next step is to save the model in the format we can use to deploy it in production.

Exporting the Model to Onnx format.

What is the ONNX format?

ONNX stands for Open Neural Network Exchange. It is an open format built to represent machine learning models in a framework and language-agnostic way.

As you may know, neural networks are computation graphs with input, weights, and operations. ONNX format is a way of saving neural networks as computation graphs. That computational graph represents the flow of data through the neural network.

The key benefits of saving neural networks in the ONNX format are interoperability and hardware access. Any deep learning platform can read a neural network saved in the ONNX format. For example, a model trained in Pytorch can be exported to ONNX format and imported in Tensorflow and vice versa.

You don’t need to use Python to read a model saved as ONNX. You can use any programming language of your choice, such as Javascript, C, or C++.

ONNX makes the model easier to access hardware optimizations. You can apply other optimizations, such as quantization, to your ONNX model.

Let us see how we can convert our model to ONNX format to use the full benefits of it.

Let’s see how we can achieve that with the code.

from pathlib import Path
model_repository = Path.cwd().parent.joinpath("models_repository")
embedding_model_path = model_repository.joinpath("retrieval", "embedding_model", "1")
embedding_model_path.mkdir(exist_ok=True, parents=True)


model_path


!ls {model_path. __str__ ()}


tuple(encoded_input.values())


from torch.onnx import export as torch_onnx_export

torch_onnx_export(
    base_model,
    tuple(encoded_input.values()),
    f=embedding_model_path.joinpath('bio-bert-embedder.onnx'),
    input_names=['input_ids', 'attention_mask'],
    dynamic_axes={'input_ids': {0: 'batch_size', 1: 'sequence'},
                  'attention_mask': {0: 'batch_size', 1: 'sequence'},
                  'last_hidden_state': {0: 'batch_size', 1: 'sequence'}},
    do_constant_folding=True,
    opset_version=13,
)


base_model.config.save_pretrained(embedding_model_path)

With the above code, we have our model exported into ONNX format and ready to be deployed in production.

Model deployment on Docker with the ONNX Runtime.

In this section, we will learn how to use the model in a docker container.

One of the most obvious solutions is to deploy a model and wrap it in with Flask or Fastapi. While this solution can work in practice, it has some latency due to the fact that the API is written in Python. For this blog I will try a different approach, I will deploy the model using the onnx runtime which is a C++ backend. We will leverage the fact that our model in ONNX format is platform agnostic and we can deploy on any language backend.

Triton Server

Triton is a software tool for deploying machine learning models for inference. It is designed to produce high-quality inference across different hardware platforms, either GPU or CPU. It also supports inference across cloud, data center, and embedded devices.

One of the advantages of the triton server is that it supports dynamic batching and concurrent model execution.

Dynamic batching:

For models that support batching, which is the case for deep learning models, triton implements scheduling and batching algorithms. That approach combines individual requests to improve inference throughput.

Concurrency model execution is the capacity to run simultaneously multiple models on the same GPU or various GPUs.

Triton Server Backend

Triton supports different backends to execute the model. A backend is a wrapper around a deep learning framework like Pytorch, TensorFlow, TensorRT, or ONNX Runtime.

Two backend types interested us for this post: the Python Backend and the ONNX runtime backend.

The ONNX runtime backend executes ONNX models, and the Python backend allows the writing of the model logic in Python.

In this post, we will be focused on the ONNX and the Python backend.

The Triton Server

Let us set up the model repository for the triton inference server.


!touch {embedding_model_path.parent. __str__ ()}/config.pbtxt

!mkdir -p {embedding_model_path.parent. __str__ ()}/ensemble_model/1
!touch {embedding_model_path.parent. __str__ ()}/ensemble_model/config.pbtxt

!mkdir -p {embedding_model_path.parent. __str__ ()}/tokenizer/1
!touch {embedding_model_path.parent.parent. __str__ ()}/tokenizer/1/model.py

!touch {embedding_model_path.parent. __str__ ()}/tokenizer/config.pbtxt

This bash script will create the model repository for our embedding model. The next section will set up the files in that model repository to run our models.

The model repository should have three components, the tokenizer, the embedding model, and the ensemble model. The tokenizer is the configuration of our tokenizer model, it uses the Python backend and handles the tokenization of our text input. The tokenizer repository should have the files from our tokenizer, the model code, and the model configuration.

It should have the following layout:

└── tokenizer
    ├── 1
    │ ├── __pycache__
    │ ├── config.json
    │ ├── model.py
    │ ├── special_tokens_map.json
    │ ├── tokenizer.json
    │ ├── tokenizer_config.json
    │ └── vocab.txt
    └── config.pbtxt

To create the tokenizer file, we will have to save our tokenizer to the tokenizer repository, we will use the following code.

model_repository



tokenizer_path = model_repository.joinpath("retrieval", "tokenizer")
tokenizer_path = tokenizer_path.joinpath("1")
tokenizer.save_pretrained(tokenizer_path)

From that tokenizer, we will create the model.py file, which will handle the tokenization part.

Here is what the model should look like

%%writefile {embedding_model_path.parent.parent. __str__ ()}/tokenizer/1/model.py
import os
from typing import Dict, List

import numpy as np
import triton_python_backend_utils as pb_utils
from transformers import AutoTokenizer, PreTrainedTokenizer, TensorType

class TritonPythonModel:
    tokenizer: PreTrainedTokenizer

    def initialize(self, args: Dict[str, str]) -> None:
        """
        Initialize the tokenization process
        :param args: arguments from Triton config file
        """
        # more variables in https://github.com/triton-inference-server/python_backend/blob/main/src/python.cc
        path: str = os.path.join(
            args["model_repository"], args["model_version"])
        self.tokenizer = AutoTokenizer.from_pretrained(path)

    def execute(self, requests) -> "List[List[pb_utils.Tensor]]":
        """
        Parse and tokenize each request
        :param requests: 1 or more requests received by Triton server.
        :return: text as input tensors
        """
        responses = []
        # for loop for batch requests (disabled in our case)
        for request in requests:
            # binary data typed back to string
            query = [
                t.decode("UTF-8")
                for t in pb_utils.get_input_tensor_by_name(request, "TEXT")
                .as_numpy()
                .tolist()
            ]
            tokens: Dict[str, np.ndarray] = self.tokenizer(
                text=query, return_tensors=TensorType.NUMPY, padding=True, truncation=True
            )
            # tensorrt uses int32 as input type, ort uses int64
            tokens = {k: v.astype(np.int64) for k, v in tokens.items()}
            # communicate the tokenization results to Triton server
            outputs = list()
            for input_name in self.tokenizer.model_input_names:
                tensor_input = pb_utils.Tensor(input_name, tokens[input_name])
                outputs.append(tensor_input)

            inference_response = pb_utils.InferenceResponse(
                output_tensors=outputs)
            responses.append(inference_response)

        return responses

The initialize method from this class will create our tokenizer from this folder. All our tokenizer files will be initialized from it.

The execute method is the one that handles the request. It can take multiple requests and parse them. Finally, create the query from the text, and return the tokenized text.

With our tokenizer setup, let us configure the Python server to use it.

The content of the tokenizer/config.pbxt should look like this.

%%writefile {embedding_model_path.parent.parent. __str__ ()}/tokenizer/config.pbtxt

name: "tokenizer"
max_batch_size: 0
backend: "python"

input [
{
    name: "TEXT"
    data_type: TYPE_STRING
    dims: [-1]
}
]

output [
{
    name: "input_ids"
    data_type: TYPE_INT64
    dims: [-1, -1]
},
{
    name: "attention_mask"
    data_type: TYPE_INT64
    dims: [-1, -1]
}
]

instance_group [
    {
      count: 1
      kind: KIND_CPU
    }
]

In this file, we specify that our backend is a Python backend. It will take an input named text, with dimension -1. The dimension -1 means dynamic or it can be of any size. It returns the inputs_ids, and the attention_mask and will run on a CPU.

The second component of our model is the embedding model itself, it has the following layout:

├── embedding_model
│ ├── 1
│ │ ├── bio-bert-embedder.onnx
│ │ └── config.json
│ └── config.pbtxt

Let's look at the config.pbtxt for the embedding model

embedding_model_path


%%writefile {embedding_model_path.parent. __str__ ()}/config.pbtxt

name: "embedding_model"
platform: "onnxruntime_onnx"
backend: "onnxruntime"
default_model_filename: "bio-bert-embedder.onnx"
max_batch_size: 0
input [
  {
    name: "input_ids"
    data_type: TYPE_INT64
    dims: [-1, -1]
  },
{
    name: "attention_mask"
    data_type: TYPE_INT64
    dims: [-1, -1]
  }
]
output [
  {
    name: "3391" # not sure why this is name 3391, need to double check
    data_type: TYPE_FP32
    dims: [-1, 1024]
  }
]

instance_group [
    {
      count: 1
      kind: KIND_CPU
    }
]

It is the configuration file for our embedding model, we can see that it takes the output from our tokenizer model and produces the embedding vector of shape, -1, 1024. With -1 meaning the dynamic shape, and 1024 is our embedding size.

Note: for some reason, the model output is named 3391 I don’t know why it is named like that.

We can connect our embedding model and the tokenizer’s input and output with the ensemble model. It should have the following layout:

├── ensemble_model
│ ├── 1
│ └── config.pbtxt

And the content of the config.pbtxt file in the ensemble model should be like this:

%%writefile {embedding_model_path.parent.parent. __str__ ()}/ensemble_model/config.pbtxt
name: "ensemble_model"
# maximum batch size 
max_batch_size: 0 
platform: "ensemble"

#input to the model 
input [
{
    name: "TEXT"
    data_type: TYPE_STRING
    dims: [-1] 
    # -1 means dynamic axis, aka this dimension may change 
}
]

#output of the model 
output {
    name: "3391"
    data_type: TYPE_FP32
    dims: [-1, 1024] 
    # two dimensional tensor, where 1st dimension: batch-size, 2nd dimension: #classes, not sure why name is 3391.
}

#Type of scheduler to be used
ensemble_scheduling {
    step [
        {
            model_name: "tokenizer"
            model_version: -1
            input_map {
            key: "TEXT"
            value: "TEXT"
        }
        output_map [
        {
            key: "input_ids"
            value: "input_ids"
        },
        {
            key: "attention_mask"
            value: "attention_mask"
        }
        ]
        },
        {
            model_name: "embedding_model"
            model_version: -1
        input_map [
            {
                key: "input_ids"
                value: "input_ids"
            },
            {
                key: "attention_mask"
                value: "attention_mask"
            }
        ]
        output_map {
                key: "3391"
                value: "3391"
            }
        }
    ]
}

In a nutshell, this config connects our tokenizer and the embedding model. The output of the tokenizer model is passed to the embedding model to produce the embedding vector.

If the three components were configured correctly we should have the following layout:


models_repository/retrieval
├── embedding_model
│ ├── 1
│ │ ├── bio-bert-embedder.onnx
│ │ └── config.json
│ └── config.pbtxt
├── ensemble_model
│ ├── 1
│ └── config.pbtxt
└── tokenizer
    ├── 1
    │ ├── __pycache__
    │ ├── config.json
    │ ├── model.py
    │ ├── special_tokens_map.json
    │ ├── tokenizer.json
    │ ├── tokenizer_config.json
    │ └── vocab.txt
    └── config.pbtxt

If you have all the following components we can go to the next stage.

Building the triton Inference server image.

In this section, we will see how to build the triton inference server image. The base triton inference server docker image is huge and can weigh up to 10 GB. In the triton inference server there is a way to build a Cpu only image for triton. I wasn’t able to build it from my Macbook.

We will be using the image Jackie Xiao built for that purpose.

It is a CPU-only image, hence the small size of 500Mb. If you are deploying the model in an infrastructure with a GPU, you will need to use the full Triton Image which is huge.

Here is the docker file used to build this image.

%%writefile {Path.cwd().parent. __str__ ()}/Dockerfile

# Use the base image
FROM jackiexiao/tritonserver:23.12-onnx-py-cpu

# Install the required Python packages
RUN pip install transformers==4.27.1 sacremoses==0.1.1

You can see that we are pulling the base image and install in it the transformer and the Moses tokenizer.

With that docker image, we can build the docker image.

docker build -t espymur/triton-onnx-cpu:dev -f Dockerfile .

If the image was successfully built we push it to the docker image repository:

docker push espymur/triton-onnx-cpu:dev

After pushing the image to the repository, you can start your docker container with the triton server in it.


 docker run --rm -p 8000:8000 -p 8001:8001 -p 8002:8002 -v ${PWD}/models_repository/retrieval:/models espymur/triton-onnx-cpu:dev tritonserver --model-repository=/models

This command does the following:

It starts the docker container with the triton-onnx-cpu:dev image.

It exposes the different ports from the container to the external environment:

For HTTP connection, it maps the port 8000 from the container to the port 8000 of the external environment.

For GRPC, it maps the port 8001 to the port 8001.

For the metric server, it maps the port 8002 to the port 8002

It maps the local directory, named model_repository to the folder named /models in the docker container by using volumes.

We specify that the triton server should use the model folder as the model repository.

If everything goes well with that command you should be able to see the following output which tells us which port is used by the model.


I0329 18:42:18.452806 1 grpc_server.cc:2495] Started GRPCInferenceService at 0.0.0.0:8001

I0329 18:42:18.460674 1 http_server.cc:4619] Started HTTPService at 0.0.0.0:8000

I0329 18:42:18.520315 1 http_server.cc:282] Started Metrics Service at 0.0.0.0:8002

With that code, we have our embedding API running and we can now send requests to it.

Making Request to the inference Server.

We have now built our model, the next step is to make an inference request to it and analyze the response.

Since the model is deployed as a REST API you can make inference requests to it using any client of your choice in any language

. The inference server is very strict in terms of what it expects as input, and how to interact with it. Fortunately, they have described different clients to use to build the inputs.

For demonstration purposes, I will be using the Python HTTP client to make the inference requests.

But nothing restricted you from using your language of choice to make HTTP requests to the API.

import numpy as np
import tritonclient.http as httpclient
url = "localhost:8000"
http_client = httpclient.InferenceServerClient(url=url,verbose=False)

The above code creates the HTTP client, with our server url, let us define the input and output of it.

text_input = httpclient.InferInput('TEXT', shape=[1], datatype='BYTES')

embedding_output = httpclient.InferRequestedOutput("3391", binary_data=False)

Those are the placeholder for our inputs and output, let us fill them now:

sentences = ["what cause covid"]
np_input_data = np.asarray([sentences], dtype=object)


np_input_data.reshape(-1)


text_input.set_data_from_numpy(np_input_data.reshape(-1))


results = http_client.infer(model_name="ensemble_model", inputs=[text_input], outputs=[embedding_output])


results

We can now convert back the output to numpy using

inference_output = results.as_numpy('3391')
print(inference_output.shape)

That is all we have our embedding API, which takes the text and produces the embedding vector.

Conclusion

In this post, we have learned how to deploy an embedding model as an API using the triton inference server. The knowledge learned in this post can be used to deploy any transformer model with an encoder or decoder using the triton inference server. Any model from the BERT, or GPT family. It can slightly be adapted to use with encoder-decoder models such as T5 or M2M.

Once we deploy the model to the production server it will grow with users and need to scale. In the second part of this series, we will learn how to scale the model using Kubernetes.

A Letter to LinkedIn Recruiters

Espoir Murhabazi — Mon, 11 Apr 2022 23:02:11 +0000

Dear LinkedIn Hiring Managers and Aka Tech Recruiters,

I am writing to you people on behalf of my fellow developers.

Thank you for always trying to reach out to us, even if we mentioned that we are not looking for opportunities on our LinkedIn profiles. We appreciate the courage. We know what it takes for a man to try to date a woman who is in a relationship or married.

First, where were you when we were still based in the South? Africa, South America, or Asia? Why did you wait for us to be in Europe or America to start sending us your emails? Don't you know that the future of work is remote and that relocation exists? Brilliance is evenly distributed but opportunities are not. Please give opportunities to everyone.

Please, next time, if you are reaching out to us, please take some time to go over our profiles and read them carefully. Take some time to go over our Github pages as well. Most of the time, googling our name will take you to our portfolios. Don’t just copy-paste an email and send it to a list of people. This is how some of you requested a creator of a framework with four years of experience in the framework he created three years ago. Please do your research.

If we have agreed to discuss this with you, please, first of all, show up. We know the whole feeling of being ghosted and how it hurts. If we are talking on the phone, please make sure you read our CV/resume before; we don’t want to be asked questions about the technologies we are familiar with or proficient with. Learn our jargon. If we told you that we are proficient with the PyData Stack, why do you keep asking us if we know Pandas and Numpy? If we told you that we have worked with SpringBoot, why keep asking us if we know Java?

More importantly, never ask us for our salary expectations on the first call, tell us about the budget you have for the role, and that will be enough. Or even worse, asking us for our current salary. If we are currently underpaid, why try to continue with the same schema?

If you keep doing things like this and don’t change your practices, we will run away from your Linkedin and start posting our CV in JSON format to allow only people who can read them.

Regards.

Sincerely Busy Developers.

PS: I am not looking for work. I am happy with my current role, don’t try to reach out to me again after reading this message.

How I break up with pip and fall in love with poetry my new girlfriend.

Espoir Murhabazi — Sun, 17 Oct 2021 15:33:42 +0000

I have recently stumbled across poetry new dependency management for python and decided to give it a try.

I have been a die hard fan of pip and had used it in most of my projects before I discovered poetry. Furthermore, I had heard about pyenv in the past but was reluctant to use it in my projects for preference reasons. Since Python dependency management is an interesting topic, I would like to explain the difference in another article such as pip vs pyenv vs petry.

When I discovered poetry and tested it, I fell in love with it.

What is poetry?

Although I will be talking about girlfriends, falling in love , and breakups in this article, the poetry I am talking about is not about love, prose, poems, or Shakespeare.

Poetry is a tool for dependency management and packaging in Python. It allows you to declare the libraries your project depends on and it will manage (install/update) them for you. It supports Python 2.7 and 3.5+

If you work with python and install packages you should be familiar with pip my old girlfriend.

Why we should use poetry in lieu of pip?

After 2 weeks of usages and successful migration of five personal projects from pip to poetry, I can choose poetry because :

It has a good dependency resolver. It does the job better than PIP. Read the interesting article www.activestate.com. The author explicitly said

Unfortunately, pip makes no attempt to resolve dependency conflicts. For example, if you install two packages, package A may require a different version of a dependency than package B requires.

And another advantage I found is that anytime you add a new dependency to the project poetry update for you the pyproject.toml with the new top-level dependency, it, therefore, avoid you to do pip freeze to generate a new requirement file for your project.
You can use the same tool to build and publish your packages. And it is easy to do so. I my opinion this is why I think poetry outweighed pip

On one hand, I think poetry outweigh pip in many aspects. On the other hand, I view it as pip on steroids

In the following sections, I will guide you on how to migrate an existing project from pip to poetry.

Installing Poetry in your system

Installing poetry is very straightforward, if you have python installed and curl you can easily install it by running :

osx / linux / bashonwindows install instructions

curl -sSL https://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py | python -

windows powershell install instructions

(Invoke-WebRequest -Uri https://raw.githubusercontent.com/python-poetry/poetry/master/install-poetry.py -UseBasicParsing).Content | python -

Warning : The previous get-poetry.py installer is now deprecated, if you are currently using it you should migrate to the new, supported, install-poetry.py installer.

The installer installs the poetry tool to Poetry’s bin directory. This location depends on your system:

$HOME/.local/bin for Unix
%APPDATA%\Python\Scripts on Windows

If this directory is not on your PATH, you will need to add it manually if you want to invoke Poetry with simply poetry.

Alternatively, you can use the full path to poetry to use it.

There is also another version of installing it with pip but why would you use your ex to attract your new girlfriend? 🤔🤪

Once everything is installed you can restart your terminal and run the following command to check the poetry version:

poetry --version

If installation is unsuccessfully or encountering incompatibility issues. Please heads up to Github Poetry to get a help, to learn more or to fire an issue.

The Migration

Generate top-level dependencies

Before moving to the next step you need to make sure you can generate the top-level dependencies for your project, to do that you will need a package called pipdeptree . For context, the top-level dependencies are the root of your dependencies tree. What is even the dependency tree? Each package you install using pip has the other dependencies that rely on it. And before installing a new package it installs his top-level dependencies. For example, pandas is a package but pandas depends on numpy, if you install pandas it install also numpy as a dependent.

The following command will generate only the top-level dependencies, so if you have installed pandas, it will just generate pandas and not numpy as a requirement.

Why is this important? :

This should be filled

pipdeptree --warn silence | grep -E '^\w+' > requirements-new.txt

Once you have generated the top-level dependencies, I would suggest you deactivate your virtual environment and delete it to make the break-up complete before moving to the next steps.

Adding poetry to an existing project.

If you have a new project where you are using pip and have the requirements.txt file inside you can run the following command to initialize poetry in the project.

poetry init

This will prompt you to set up poetry to your existing project and asked you to give some details about your project such as the project name, the python version you want to use, and the description. It will consequently generate the pyproject.toml file which will contain all the details about your project as well as the top-level projects requirement and their versions.

Creating virtual environment

Poetry creates by default virtual environment in a folder called ~/Library/Application Support/pypoetry but you can change those settings by using the following command :

poetry config virtualenvs.in-project true

After running that command you can run the following :

poetry shell

It will activate the project’s virtual environment and create a new one if the project does not have one.

Installing the requirements for your projects.

If you have the requirements-news.txt file resulting from the command you run on the first step, you can install all the packages in that and their corresponding version by running the following command:

for item in $(sed -n 's/==/@/p' requirements-new.txt); do poetry add "${item}" ; done

This will work only on Linux and Mac, still trying to find the exact version of it for Windows.

What does that command do? I loop over every line of the requirement-new.txt file take the dependency, and just replace the == in the dependency with @ and then add it with poetry.

If for example in the file you have pandas==1.1.1, it will install the following with poetry poetry add pandas@1.11

If everything goes well you should have the all the top-level packages installed with their dependencies.

Once the command has successfully run and you have everything installed, you should check if your pyproject.toml file contains all the packages and their top-level dependencies.

You can now remove the old requirements.txt file and the newly create requirement-new.txtfile by running.

rm -f requirements.*

A section about using poetry with conda enviroment

Some people like to have multiples girlfriend and may like to keep their old conda or pip environment. I haven’t tried this approach yet , but according tothis issue it is possible to use poetry to install packages in a python environment.

You just have to configure poetry to not create a virtual environment in a project and install your packages in the conda or pip environment.

I think you can try it and let us know in comment how it goes.

Bonus, the Dockerfile.

If you have a dockerfile you can edit it and use the following docker images which use multi-stage build to install all your requirement with poetry.

FROM python:3.7.5 AS base
LABEL maintainer="Espoir Murhabazi < first_name.second_name[:3] on gmail.com>"

ENV PYTHONUNBUFFERED=1 \
PYTHONDONTWRITEBYTECODE=1 \
PIP_NO_CACHE_DIR=off \
PIP_DISABLE_PIP_VERSION_CHECK=on \
PIP_DEFAULT_TIMEOUT=100 \
POETRY_HOME="/opt/poetry" \
POETRY_VIRTUALENVS_IN_PROJECT=true \
POETRY_NO_INTERACTION=1 \
PYSETUP_PATH="/opt/pysetup" \
VENV_PATH="/opt/pysetup/.venv"

ENV PATH="$POETRY_HOME/bin:$VENV_PATH/bin:$PATH"

FROM base AS python-deps

RUN apt-get update \

&& apt-get install --no-install-recommends -y \

curl \

build-essential
# Install Poetry - respects $POETRY_VERSION & $POETRY_HOME
ENV POETRY_VERSION=1.1.7

RUN curl -sSL https://raw.githubusercontent.com/sdispater/poetry/master/get-poetry.py | python
WORKDIR $PYSETUP_PATH

COPY ./poetry.lock ./pyproject.toml ./
RUN poetry install --no-dev
FROM base AS runtime
COPY --from=python-deps $POETRY_HOME $POETRY_HOME
COPY --from=python-deps $PYSETUP_PATH $PYSETUP_PATH
RUN useradd -ms /bin/bash espy
COPY . /home/espy
WORKDIR /home/espy
USER espy
CMD [" you command "]

Basically, what the docker file does, it uses a multi-stage build to first install the packages in the first step and copy only the packages installed in the second as well as the project repository. One of the advantages of the multi-stage build is that it uses only the necessary files your project needs and therefore reduce the memory of your docker container.

You can learn more about multi-stage build using the following tutorial.

Conclusion

And the story of my break up comes to an end. As you may know, all separations are not smooth, sometimes the daemons of your old girlfriend come and start causing troubles in your new relationship. So if you find any issue during this break-up, feel free to let me know in the comment I will try to help you as much as I can 🤔.

My books recommendations to enhance your Soft Skills as a developer

Espoir Murhabazi — Sat, 05 Jun 2021 12:57:09 +0000

Three years ago, I decided to part ways with my Facebook account, and I decided to replace the time spent on Facebook with reading developers’ blogs. During that time, I stumbled across dev, medium, and quora. These sites and publications have contributed a lot to the developer I am today. I decided to dig deeper in my social media detox. Last year, I decided to block WhatsApp status unless Man-City qualified for the Champions League final and spent the time reading books about soft skills to improve my softs skills as a developer.

I am not planning to talk about the pros and cons of not having a social media account here; instead, I will talk about a few books I read recently, which improved my soft skills as a developer.

Dale Carnegie, How to Win Friends & Influence People, 1998 Edition

After the Bible, this is the best and essential book in my life. It has improved my life, not only as a developer but also as a person in general. It helps me improve my communication skills, communicate with anyone, avoid arguments, and be a good leader.

The first aspect I appreciate from this book comes from the introduction, where the author explains how we should read the book to gain most of it. Those pieces of advice were very useful for every other book I read after this one.

After reading this book, my communication skills got better, and I was able to land a job with a triple of my previous salary.

My favorite quote from the book is :

The highest-paid personnel in engineering are frequently not those who know the most about engineering. The person who has technical knowledge plus the ability to express ideas, assume leadership, and arouse enthusiasm among people – that person is headed for higher earning power.

If you would like to improve your soft skills and be better at communication, I recommend this book.

There are numerous benefits of reading this book; I remember in the third chapter where the author wrote: “the best way to win your friend into your way of thinking is to talk about the other person’s interest.” Later in the chapter about arguments when the author said : " you can’t win an argument. A man convinced against his will is of the same opinion still”. _

James Clear, Atomic Habits: An Easy & Proven Way to Build Good Habits & Break Bad Ones, 2018 Edition

The second book is a recent bestseller, and it is not about communication but rather about building good habits. Have you ever found yourself in the bad habit of checking social media every time you are working? Are you constantly failing to start a habit of something you care about and know is essential for your health, such as reading a book or exercising every day? Do you need to improve your productivity as an Engineer ? I recommend the book Atomic Habits by James Clear.

The book explains how getting 1% better every day can be beneficial over time. From the first chapter, I learned how small habits compound over time.

As you can see in the picture below :

“The effects of small habits compound over time. For example, if you can get just 1 percent better each day, you’ll end up with results that are nearly 37 times better after one year.”

The book’s backbone is a four-step model of habits - cue, craving, response, reward, and the four laws of behavior change that evolve out of these steps. The mastery of those four laws is an essential step for everyone who wants to build better habits.

Make it obvious, Make it attractive, Make it easy and Make it satisfying.

By understanding those laws, on the one hand, you will learn how addictive products such as video games or social media applications are built. On the other hand, you can learn how to use the same psychological tips in those products to your favor when building solid habits. Lessons learned from that book can easily be applied to a software development career, especially if you want to develop strong habits within your software development team.

Robert Kiyosaki, Rich Dad Poor Dad: What the Rich Teach Their Kids About Money That the Poor and Middle Class Do Not 2017 Edition.

The third book is neither on leadership nor habits, but it is a financial best-seller Rich Dad, Poor Dad. Do you want to be financially free, never to be broke again? This book is for you. The author of the book exposes two contrasting views about money from his two dads; the one he called poor dad, his real dad who was working for the government and taught him to work for money, and his rich dad, who was his best friend’s dad who taught him how to let the money work for him. From the book, I learned the difference between assets and liability and why we should buy assets instead of liabilities.

There are numerous lessons I learned from the book, but here is the most important one :

The cone of learning

Rich don’t work for money. They work to learn how to let money work for them one day.
The ability to sell—to communicate to another human being, be it a customer, employee, boss, spouse, or child—is the base skill of personal success.
Never Say I can’t afford it, or I can do it, instead ask yourself how I can afford it or do it?

By completing this book, I realized how important it is to be financially free, and I decided to start thinking about building my own company.

Napoleon Hill, Think and Grow Rich, 1937.

Another interesting book I read which is similar to the previous one is: Think and Grow Rich by Napoleon Hill.

I haven’t yet finished the book, but it has numerous lessons on how to get rich from what I am reading. And from the author’s perspective, the book is not only about being rich in terms of money but being rich in other aspects of your life such as marriage, health, or studies. The book highlighted 14 key success factors. The book contains stories and extracts of the most successful person on the planet bibliographies such as T. Edinson, H.Ford or Andrew Carnegie. The key concept from the book is that the rich start from someone’s mind. The author gives six key steps in which desires of riches can be transmuted to this physical equivalent. I think those steps are easy to apply, and I have started seeing their benefits in my current life.

Here is my favorite quote from the book :

“If you think you are beaten, you are

If you think you dare not, you don’t,

If you like to win, but you think you can’t

It is almost certain you won’t.

If you think you’ll lose, you’re lost

For out of the world we find,

Success begins with a fellow’s will

It’s all in the state of mind.

If you think you are outclassed, you are

You’ve got to think high to rise,

You’ve got to be sure of yourself before

You can ever win a prize.

Life’s battles don’t always go

To the stronger or faster man,

But soon or late the man who wins

Is the man WHO THINKS HE CAN!”

I haven’t yet finished the book, but the lessons in my life are enormous.

Robert C. Martin, Clean Coder, The: A Code of Conduct for Professional Programmers, 2011.

Last but not least is the book I am currently reading and the book I wish I read when I started my software development career—the Clean Coder.

The book’s author is Uncle Bob, an experienced programmer with more than 42 years of coding experience. The book is all about professionalism for software developers. It describes the actions and disciplines you should consider to be a professional developer. Most of the lessons you find from the book came from his experience and are very useful for today’s developers. From the book, you can learn how to say No and say Yes in your day-to-day job as a software engineer. How testing can help you become a professional developer. It talks about work ethics and how you should keep learning to stay updated on your skills. How to become a better team player. How to handle meetings at work and avoid working overtime and, more importantly, improving your productivity as a developer. I haven’t yet completed the book, but after reading the first two chapters of this book, I had concluded that this is the book I wish I had read when I started coding. I recommend it for every teacher who is teaching software engineering to school. It is the handbook for professionalism as a Software Engineer.

Final thoughts

That is all about books I read last year. They are not enough in comparison with books that humans have written on this earth, but in one year it is a lot, and the most important was not to read the book but to put into practice what you read from them. When I get old, I will have a large library like this one, and I can brag about them to my friends.

How do I manage to find time to read and work full time with endless bugs in a world full of distractions? The secret came from the book Atomic habits. I have made it easy for me. I have a ritual, my morning routine. I know that I have to do two things in the morning; my fitness routine, brushing my teeth, and reading for at least 30 minutes. And as a reward for this routine, I can open my phone and check if I have important emails or any notification that will boost my dopamine.

And as I said in the introduction, I learned how to gain time from social media and WhatsApp status by making the habits of checking them hard by blocking access to my contacts to WhatsApp and just deleting my Facebook account. I also use Twitter for 10 minutes per day on my laptop and from 7 pm to 10 pm on my phone and only in read-only mode.

I hope you learned something from this, and I can guarantee that you will learn more from the book I shared.

Do you have similar books to recommend to me? Feel free to leave them as a comment. Otherwise, take care and enjoy life. Cheers.

Shipping Python Code to AWS ECS using Github Actions

Espoir Murhabazi — Mon, 05 Apr 2021 13:33:07 +0000

This is the last post of this series. In the first post we learned how to build the ship for our boatload: The CloudFormation Stack and its different objects); in The second we learned how to build containers; finally, in this one, we will find how to ship those containers to our boat using Github Actions.

This is not a post about Github Actions or CI/CD, to get started with those concepts there are a tremendous amount of tutorials online for that.

If by any chance you are not familiar with CI/CD or Github actions in general refer to this guide and this one to get started.

Getting started

To get started download a sample project we will be using by running the following command in your cmd. I hope you have git installed in your machine.

git clone https://github.com/espoirMur/deploy_python_to_aws_github_actions.git

As you can see this is just a dummy project which runs with run four docker containers.

You can follow the readme to get the project running for you.

What we will accomplish and the tools we will use:

Our architecture and workflow in a nutshell

As you can see in the picture our actions, on every push to the master branch, will build a docker image for our application, log in to ECR, push the image to the ECR, update the task definition with the new image pushed URL, and start the service with the associated task definition in the AWS Cluster.

Here is a list of the GitHub actions we will be using :

Configure-aws-credentials: This will help to configure AWS credential and region environment variables for use in other GitHub Actions.
Amazon-ecr-login: This will enable us to log in to the local Docker client to one or more Amazon Elastic Container Registry (ECR) registries. After logging, we can therefore push our docker images to the registry.
Amazon ECS-render-task-definition: This will help us to render the docker image URI to the task definition.
Amazon ECS-deploy-task-definition: This is the action that does the real deploy for us. It will register the AWS task definition to ECS and then deploys it to an Amazon ECS service.
Docker Buildx: This action will help us to set up the most recent version of the docker build: buildx which support caching. It is not mandatory if you don’t need to use caching you can skip it.

Back To the Business: The code we want to deploy.

Let go back to the project I introduced in the beginning and we will work from it. From your command line move to the project directory :

cd deploy_python_to_aws_github_actions

Activate your virtual enviroment with :

source .venv/bin/activate

Creating the Github actions:

To create Github Actions we can add them from the Github UI or do it from the command line. To perform that operation via command line you need to have a folder called .github/workflows in your project directory and add your action .yml file within it.

Let us create the folder:mkdir .github && mkdir .github/workflows

Then we can create our action file with
touch .github/workflows/deploy_aws.yml

Setting up

In the deploy to AWS action we add the following code :

on:

 push:

  branches:

   - master

 name: Deploy to Amazon ECS

In this line we are only specifying the event that will trigger our action, this action will be triggered on a push to master.

Next, let us specify the set of job that our actions will run:

jobs:

 deploy:

  name: Deploy

  runs-on: ubuntu-latest

This tells our job to run on the ubuntu instance. The job has the following steps

steps:

- name: Checkout

uses: actions/checkout@v1

This action checks-out your repository under $GITHUB_WORKSPACE, so your workflow can access it.

- name: Set up Python python-version

  uses: actions/setup-python@v1

  with:

   python-version: 3.7

This action set up the python version to use for our application.

- name: Set up QEMU
  uses: docker/setup-qemu-action@v1

- name: Set up Docker Buildx
  uses: docker/setup-buildx-action@v1

This one set up the docker build tools we will be using.

- name: create docker cache
  uses: actions/cache@v1
  with:

   path: ${{ github.workspace }}/cache

   key: ${{ runner.os }}-docker-${{ hashfiles('cache/**') }}

   restore-keys: |
    ${{ runner.os }}-docker-

This one creates the cache we will be using in the build phase.

- name: generating the config files

run: |

echo '''${{ secrets.CONFIGURATION_FILE }}''' >> .env

echo "done creating the configuration file"

This one generates our configuration file, so basically if you have environment variables in a .env file, these actions will generate them back.

- name: Configure AWS credentials

uses: aws-actions/configure-aws-credentials@v1

with:

aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}

aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}

aws-region: us-east-2

As the name stated this action will configure your AWS credentials so that you can easily log in to the ECR.
Don’t forget to add your credentials to your Github repository secrets. If you are not familiar with how to add secrets to GitHub refer to this guide.

- name: Login to Amazon ECR

  id: login-ecr

  uses: aws-actions/amazon-ecr-login@v1

As the name stated this use the credentials set up in the previous steg to login to the container registry.

Once we are login we can now build the container and push it to the container registry.

- name: Build, tag, and push the image to Amazon ECR

  id: build-image

  env:

   ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}

   ECR_REPOSITORY: ecs-devops-repository

   IMAGE_TAG: ${{ github.sha }}

run: |

docker buildx build -f Dockerfile --cache-from "type=local,src=$GITHUB_WORKSPACE/cache" --cache-to "type=local,dest=$GITHUB_WORKSPACE/cache" --output "type=image, name=$ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG,push=true" .

echo "::set-output name=image::$ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG"

This builds the container and pushes the container registry. Note that the output of this step is the image URI or image name, we will need it in the next step.

In the next step, we will fill the image name in each container definition in our task-definition file so that the docker container will be pulling the newly built docker image.

There are 3 steps in sequence. The output of one step is used in the next step.

- name: Fill in the new image ID in the Amazon ECS task definition of the beat container

id: render-beat-container

uses: aws-actions/amazon-ecs-render-task-definition@v1

with:

task-definition: ./.aws/task-definition.json

container-name: celery-beat

image: ${{ steps.build-image.outputs.image }}

- name: Fill in the new image ID in the Amazon ECS task definition of the flower container

id: render-flower-container

uses: aws-actions/amazon-ecs-render-task-definition@v1

with:

task-definition: ${{ steps.render-beat-container.outputs.task-definition }}

container-name: flower

image: ${{ steps.build-image.outputs.image }}

- name: Fill in the new image ID in the Amazon ECS task definition of the worker container

id: render-worker-container

uses: aws-actions/amazon-ecs-render-task-definition@v1

with:

task-definition: ${{ steps.render-flower-container.outputs.task-definition }}

container-name: celery-worker

image: ${{ steps.build-image.outputs.image }}

With the task definition updated we can now push the task definitions to the service and start running the service.

- name: Deploy Amazon ECS task definition

uses: aws-actions/amazon-ecs-deploy-task-definition@v1

with:

task-definition: ${{ steps.render-worker-container.outputs.task-definition }}

service: ecs-devops-service

cluster: ecs-devops-cluster

wait-for-service-stability: false

This is the step that does the actual deployment, it pushes the task definitions to the service which starts the tasks.

With this added we can make sure we have the following content in our .github/workflows/deploy_aws.yml file.

on:

push:

branches:

- master

name: Deploy to Amazon ECS

jobs:

deploy:

name: Deploy

runs-on: ubuntu-latest

steps:

- name: Checkout

uses: actions/checkout@v1

- name: Set up Python python-version

uses: actions/setup-python@v1

with:

python-version: 3.7

- name: Set up QEMU

uses: docker/setup-qemu-action@v1

# https://github.com/docker/setup-buildx-action

- name: Set up Docker Buildx

uses: docker/setup-buildx-action@v1

- name: create docker cache

uses: actions/cache@v1

with:

path: ${{ github.workspace }}/cache

key: ${{ runner.os }}-docker-${{ hashfiles('cache/**') }}

restore-keys: |

${{ runner.os }}-docker-

- name: generating the config files

run: |

echo '''${{ secrets.CONFIGURATION_FILE }}''' >> .env

echo "done creating the configuration file"

- name: Configure AWS credentials

uses: ws-actions/configure-aws-credentials@v1

with:

aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}

aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}

aws-region: us-east-2

- name: Login to Amazon ECR

id: login-ecr

uses: aws-actions/amazon-ecr-login@v1



- name: Build, tag, and push the image to Amazon ECR

id: build-image

env:

ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}

ECR_REPOSITORY: ecs-devops-repository

IMAGE_TAG: ${{ github.sha }}

run: |

docker buildx build -f Dockerfile --cache-from "type=local,src=$GITHUB_WORKSPACE/cache" --cache-to "type=local,dest=$GITHUB_WORKSPACE/cache" --output "type=image, name=$ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG,push=true" .

echo "::set-output name=image::$ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG"

- name: Fill in the new image ID in the Amazon ECS task definition of the beat container

id: render-beat-container

uses: aws-actions/amazon-ecs-render-task-definition@v1

with:

task-definition: ./.aws/task-definition.json

container-name: celery-beat

image: ${{ steps.build-image.outputs.image }}

- name: Fill in the new image ID in the Amazon ECS task definition of the flower container

id: render-flower-container

uses: aws-actions/amazon-ecs-render-task-definition@v1

with:

task-definition: ${{ steps.render-beat-container.outputs.task-definition }}

container-name: flower

image: ${{ steps.build-image.outputs.image }}

- name: Fill in the new image ID in the Amazon ECS task definition of the worker container

id: render-worker-container

uses: aws-actions/amazon-ecs-render-task-definition@v1

with:

task-definition: ${{ steps.render-flower-container.outputs.task-definition }}

container-name: celery-worker

image: ${{ steps.build-image.outputs.image }}
- name: Deploy Amazon ECS task definition
uses: aws-actions/amazon-ecs-deploy-task-definition@v1

with:

task-definition: ${{ steps.render-worker-container.outputs.task-definition }}

service: ecs-devops-service

cluster: ecs-devops-cluster

wait-for-service-stability: false

With that, we can now commit the code and see how the application will start the pipeline and get deployed to AWS. Run the following to deploy.

git commit -am 'setup the ci cd pipeline'

`git push origin master

We can check if our GitHub actions are running

If everything goes well you can visualize the deployment here

Please change your service and cluster with your cluster name and service name in the URL.

If everything in your deployment goes well you can check the logs for your worker to see what is happening there

Troubleshooting:

Let me quote Albert Einstein here:

Theory is when you know everything but nothing works. Practice is when everything works but no one knows why. In our lab, theory and practice are combined: nothing works and no one knows why. 🤪

In theory, things should go as expected and everything should work in the first place, but in practice that is not always the case.

In case you got some issue making this work, first, make sure that in your GitHub actions and the task definition you put the correct name of the objects you created with the cdk.
In case you are using an application that connects to a managed database, make sure you have a security group attached to your instance that is allowed to make connections to the database. Security groups and networking is beyond the scope of this blog, maybe in the fourth part of the series I can talk a little about it.
If after deploying nothing is running you can check the status of your tasks using the following code:

aws ecs list-tasks --cluster ecs-devops-cluster --region us-east-2 --desired-status STOPPED

to get the task stopped ARN.
And then use the following ARN in this code to check the reason why it has stopped :

aws ecs describe-tasks --cluster ecs-devops-cluster --tasks task_arn_from_previous_step --region us-east-2 --debug

If you are lucky enough you should see why your tasks are not working here.

Conclusions

In these three-part series we learned how to create a scalable architecture to deploy our python application to AWS, we learned also how to use Github actions to deploy a simple application to AWS. And to sum up we add some useful commands you can use to troubleshoot an AWS service and tasks. I hope you enjoy reading this tutorial. If you encountered any issues while working on this, feel free to let us know in the comments.

In meantime take care of yourself and happy coding.

Ressources

Here is a non-exhaustive list of resources I used in this blog post :

Converting a docker-compose file to an AWS task definition

Espoir Murhabazi — Thu, 25 Mar 2021 10:03:25 +0000

In the previous post, we learned how to create an AWS Architecture to support our Python Application . In this post, we will learn how to create a task-definition from a docker-compose file.

Before diving deep into the tutorial, let us define what is a docker-compose file and recall from the previous tutorial what is a task-definition.

What is docker-compose?:

From this tutorial, docker-compose is defined as :

Docker Compose is a way to create reproducible Docker containers using a config file instead of extremely long Docker commands. By using a structured config file, mistakes are easier to pick up and container interactions are easier to define.

What is a task definition:

Let’s recall what a task-definition is: it is just a specification. You use it to define one or more containers that you want to run together, along with other details such as environment variables, CPU/memory requirements, etc.

From the two definitions, we can see that a task definition role is similar to that of a docker-compose file.

We will therefore use the docker-compose file to generate the task-definition.

The real stuff, the transformation :

To make our transformation, we can go back to the project we introduced in the first part and cd to the project directory.

We will leverage a python tool called container-transform to accomplish our transformation.

You can install it in your project virtual environment with :

pip install container-transform

With the tool installed we can now use it to generate the task definition file.

cat docker-compose.yml | container-transform -v > .aws/task-definition.json

The output of this command is sent to the file .aws/task-definition.json , if everything went well you will have something like this :




{

"containerDefinitions": [

{

"command": [

"celery",

"-A",

"celery_factory:celery",

"beat",

"-S",

"redbeat.RedBeatScheduler",

"--loglevel=info"

],

"essential": true,

"image": "task_runner",

"links": [

"redis"

],

"name": "celery-beat"

},

{

"command": [

"celery",

"worker",

"-A",

"celery_factory:celery",

"--loglevel=info",

"-E"

],

"essential": true,

"image": "task_runner",

"links": [

"redis"

],

"name": "celery-worker"

},

{

"command": [

"./start_flower"

],

"environment": [

{

"name": "FLOWER_PORT",

"value": "5556"

}

],

"essential": true,

"image": "task_runner",

"links": [

"redis"

],

"name": "flower",

"portMappings": [

{

"containerPort": 5556,

"hostPort": 5556

}

]

},

{

"essential": true,

"image": "redis",

"name": "redis"

}

],

"family": "",

"volumes": []

}

What to note here; all services we have in the docker-compose file are now in the containerDefinitions sections of our task definition. However, that file is not yet fully complete. We will have to update it with other keys such as the network mode, resources, execution role we created before, and the logging option for sending logs to Cloudwatch. Let’s edit the file by adding the following. We also need to remove the link key from each container definition.




"requiresCompatibilities": [



"FARGATE"



],



"inferenceAccelerators": [],

"volumes": [],



"networkMode": "awsvpc",



"memory": "512",



"cpu": "256",



"executionRoleArn": "arn:aws:iam::Your-id-from-aws:role/ecs-devops-execution-role",



"family": "ecs-devops-task-definition",



"taskRoleArn": "",



"placementConstraints": []

What are those elements?

requiresCompatibilities: here, we are specifying that our launch type is of Fargate type.
networkMode: this is the Docker networking mode to use for containers in the task. AWS offers the following network modes: none, bridge, awsvpc, and host. In the Fargate launch type, the awsvpc network mode is required. With this setting, the task is allocated its own elastic network interface (ENI) and a primary private IPv4 address. This gives the task the same networking properties as Amazon EC2 instances. Learn more about networking mode here.
memory: is the amount of RAM to allocate to containers, if your cluster does not have any registered container instances with the requested memory available, the task will fail.
cpu: The number of CPU units that the Amazon ECS container agent will reserve for the container.
executionRoleArn: The Amazon Resource Name (ARN) of the task execution role that grants Amazon ECS container agent permission to make AWS API calls on your behalf. As you can see it is the IAM role we created in our Cloudformation stack.
family: is the name of the task definition we created on the Cloudformation stack.

In each container definition, we need to add this code to send container logs to Cloudwatch.




"logConfiguration": {



"logDriver": "awslogs",



"options": {



"awslogs-group": "ecs-devops-service-logs-groups",



"awslogs-region": "us-east-2",



"awslogs-stream-prefix": "celery-beat"



}



},

Add those lines to each AWS service and change the awslogs-stream-prefix key and put the container name. To learn more about task definitions parameters, check AWS documentation

With those parameters edited we end up with the following task-definition.




{

"containerDefinitions": [

{

"command": [

"celery",

"-A",

"celery_factory:celery",

"beat",

"--scheduler=redbeat.RedBeatScheduler",

"--loglevel=debug"

],

"essential": true,

"image": "task_runner",

"environment": [

{

"name": "CELERY_BROKER_URL",

"value": "redis://127.0.0.1:6379"

}

],

"name": "celery-beat",

"logConfiguration": {

"logDriver": "awslogs",

"options": {

"awslogs-group": "ecs-devops-service-logs",

"awslogs-region": "us-east-2",

"awslogs-stream-prefix": "celery-beat"

}

}

},

{

"command": [

"celery",

"-A",

"celery_factory:celery",

"worker",

"--loglevel=error",

"-E"

],

"essential": true,

"image": "task_runner",

"name": "celery-worker",

"environment": [

{

"name": "CELERY_BROKER_URL",

"value": "redis://127.0.0.1:6379"

}

],

"logConfiguration": {

"logDriver": "awslogs",

"options": {

"awslogs-group": "ecs-devops-service-logs",

"awslogs-region": "us-east-2",

"awslogs-stream-prefix": "celery-worker"

}

}

},

{

"command": ["./start_flower"],

"environment": [

{

"name": "FLOWER_PORT",

"value": "5556"

},

{

"name": "CELERY_BROKER_URL",

"value": "redis://127.0.0.1:6379"

}

],

"essential": true,

"image": "task_runner",

"logConfiguration": {

"logDriver": "awslogs",



"options": {

"awslogs-group": "ecs-devops-service-logs",



"awslogs-region": "us-east-2",



"awslogs-stream-prefix": "celery-flower"

}

},

"name": "flower",

"portMappings": [

{

"containerPort": 5556,

"hostPort": 5556

}

]

},

{

"essential": true,

"image": "redis",

"name": "redis",

"portMappings": [

{

"containerPort": 6379

}

],

"logConfiguration": {

"logDriver": "awslogs",

"options": {

"awslogs-group": "ecs-devops-service-logs",



"awslogs-region": "us-east-2",



"awslogs-stream-prefix": "celery-redis"

}

}

}

],

"requiresCompatibilities": ["FARGATE"],



"inferenceAccelerators": [],

"volumes": [],

"networkMode": "awsvpc",

"memory": "512",

"cpu": "256",

"executionRoleArn":"arn:aws:iam::****youraws id*****:role/ecs-devops-execution-role",

"family": "ecs-devops-task-definition",

"taskRoleArn": "",

"placementConstraints": []

}

In this tutorial, we learned how to use the container-transform tool to convert a docker-compose file to an AWS task-definition.

With our task definition in place, we can now move to the third part of this tutorial where we will use the task-definition to deploy our containers to our Cloudformation stack, created in part one, using Github actions.

See you then.

How to use the AWS Python CDK to create an infrastructure on ECS.

Espoir Murhabazi — Fri, 26 Feb 2021 12:14:07 +0000

Recently at work, we decided to build a CI/CD pipeline that deploys our application directly to AWS. I had never worked with AWS, and it was a missing point on my CV which demonstrates that I have some DevOps skills. I decided to search for some tutorials online and I was not lucky to get what we needed at work. I decided to write this guide by getting something working from various tutorials I found online.

What you will learn from this series.

In this 3 parts tutorial, we will learn how to Create an AWS architecture where you can deploy an application, how to convert a docker-compose file in a Task Definition and how to deploy a Task Definition to an AWS Architecture using GitHub Actions.

Who is this series for ?

This tutorial is for developers who are familiar with docker and have an application with docker-compose. Although the series was written by a Python developer and using Python, the concepts can be applied to other programming languages.

Which application will we deploy?

In this tutorial, we will deploy a Python application that has a celery worker, a celery scheduler, and a Redis database for task messaging and task queues.

I will not talk about celery and task queues and how to use those tools but you can get start with them here, and to get started with docker you can use this one ,and this one to be familiar with docker-compose.

This series is not based on any popular Python web framework such as Django, Flask, or FastAPi but you can adapt this tutorial to them and I am sure it will work like a charm.

The application skeleton can be downloaded from this link to get started.

In this first part of the tutorial, we will learn how to create the Cloudformation stack.

What is AWS CloudFormation?

From the official documentation, Cloudformation is defined as :

AWS CloudFormation is a service that helps you model and set up your Amazon Web Services resources so that you can spend less time managing those resources and more time focusing on your applications that run in AWS. You create a template that describes all the AWS resources that you want (like Amazon EC2 instances or Amazon RDS DB instances), and CloudFormation takes care of provisioning and configuring those resources for you. You don't need to individually create and configure AWS resources and figure out what's dependent on what; CloudFormation handles all of that.

Creating the AWS Architecture

Make sure that you have created an AWS account and you have your credentials; the access key, and the application secret key.

Most of the services used in this tutorial are available within an AWS free tier.

We will deploy our application using the AWS ECS Fargate launch type which will pull docker images from the Elastic Container Registry aka ECR.

Why Fargate and not EC2?

AWS provides us basically two launch types which are the Fargate launch type and the EC2.

Amazon Elastic Compute Cloud (Amazon EC2) provides scalable computing capacity in the Amazon Web Services (AWS) Cloud. Using Amazon EC2 eliminates the need to invest in hardware upfront, so you can develop and deploy applications faster. You can use Amazon EC2 to launch as many or as few virtual servers as you need. It allows you to configure security and networking, and manage storage yourself. With EC2 you don’t have to worry about the hardware, the hardware is managed by AWS.

AWS Fargate is a technology that you can use with Amazon ECS to run containers without having to manage servers or clusters of Amazon EC2 instances. The advantage of Fargate over EC2 is the fact that you don’t have to configure, provision, or scale cluster instances and don't have to worry about the virtual machines.

In a nutshell :

With a virtual machine, someone still has to manage the hardware, but with EC2 that someone is AWS and you never even see the hardware.

With ECS on EC2, someone still has to manage the instances, but with ECS on Fargate that someone is AWS and you never even see the EC2 instances.

ECS has a “launch type” of either EC2 (if you want to manage the instances yourself) or Fargate (if you want AWS to manage the instances). Source.

The objects we need :

To deploy the application we need the following objects: a cluster, a service, a task definition with containers definition, cloud watch for logging, and IAM roles. The below picture illustrates how those AWS objects interact with each other.

Let us define some of those objects and then we will investigate how to create a stack, containing them, using Python cdk.

A cluster: It is a logical group of container instances that ECS can use for deploying Docker containers. It provides computing power to run application container instances. In practice, a cluster is usually attached to an AWS Instance.
A service: It enables us to run and maintain a specified number of instances of a task definition simultaneously in an Amazon ECS cluster. ie. It helps us run single or multiple containers all using the same Task Definition.
The task definition: A task definition is a specification. You use it to define one or more containers (with image URIs) that you want to run together, along with other details such as environment variables, CPU/memory requirements, etc. The task definition doesn’t actually run anything, it's a description of how things will be set up when something does run. The task definition shares some similarities with the docker-compose file. In the second part of this tutorial, we will convert a docker-compose file into a task definition.
A task: A task is an actual thing that is running. ECS uses the task definition to run the task; it downloads the container images, configures the runtime environment based on other details in the task definition. You can run one or many tasks for any given task definition. Each running task is a set of one or more running containers - containers in a task all run on the same instance.
cloudwatch: CloudWatch is a monitoring service, we are using it in this stack to get and visualize logs from the docker containers.

With all the objects described, we can now learn how to create them using the Python CDK.

Creating the architecture:

To build the infrastructure, we will leverage the AWS Cloud Development Kit (CDK). If you are new to CDK, see Getting Started with AWS CDK, it is simple and straightforward to install. In this post, we will be using the CDK with Python 3.7. Another alternative to the CDK is to create the application via the AWS console. However, I found the CDK to be the simplest approach because it allows you to have control over the code you are writing.

After installing the CDK check if it is working with the following command:

cdk --version should output your CDK version.

Initializing the AWS CLI :

Make sure you have AWS CLI installed on your computer. Configure your AWS CLI with an IAM user that has permissions to create the resources (VPC, ECS, ECR, IAM Role) described in the template below. After the configuration you should have the AWS keys stored in your computer at the following location :

~/.aws/credentials: if you are using Mac or Linux
C:\Users\USERNAME\.aws\config: if you are on Windows

The content of that file should look like this one:




[default]

region=your region

aws_access_key_id = *********************************

aws_secret_access_key = ******************************

With the credentials, the cli client and the CDK installed let us move to the second step about creating the architecture.

Initializing The CDK Project :

To initialize the CDK we will create a new Python project which will contain the code to create the architecture.

Step 1: Creating the project

Run the following command to create a new CDK project:

mkdir ecs-devops-cdk

Enter the project using:

cd ecs-devops-cdk

Or if you are using VSCode you can open the project with vs code using:

code ecs-devops-cdk

Step 2: Initialize the python CDK project :

To initialize the CDK project run the following command:

cdk init --language python

The command will create a new python CDK project and we will be editing it in the next step to build our stack.

After a quick look you should see a structure like this in your project:




.

├── README.md

├── app.py

├── cdk.json

├── ecs_devops_cdk

│ ├── __init__.py

│ └── ecs_devops_cdk_stack.py

├── requirements.txt

├── setup.py

└── source.bat

Step 3: activate virtual environment :

You can activate your virtual environment using the following command :

On mac and linux : source .env/bin/activate

For windows : .env\Scripts\activate.bat

step 4: Installing dependencies:

With the virtual environment created we can now install the dependencies :

pip install -r requirements.txtandpip install aws_cdk.aws_ec2 aws_cdk.aws_ecs aws_cdk.aws_ecr aws_cdk.aws_iam

With the project initialized we can now move to the next step where we will be creating our components.

Creating the objects :

We can now move to the stack creation step

If you open the file under ecs_devops_cdk/ecs_devops_cdk_stack.py you should be able to see the followings :




from aws_cdk import core

class EcsDevopsCdkStack(core.Stack):

def __init__ (self, scope: core.Construct, construct_id: str, **kwargs) -> None:

super(). __init__ (scope, construct_id, **kwargs)

It is basically a class that will contain the code defining our stack.

step 1: Import the core functionality

Edit the first line to import the code we need to create the following stack:

`python

from aws_cdk import (core, aws_ecs as ecs, aws_ecr as ecr, aws_ec2 as ec2, aws_iam as iam, aws_logs)`

step 2: Create the container repository

To create a container repository you can use the following command :




ecr_repository = ecr.Repository(self, "ecs-devops-repository", repository_name="ecs-devops-repository")

step 3: Creating the VPC :

We can either create a vpc or use an existing vpc. To create a vpc use can add the following code the __init__ method.




vpc = ec2.Vpc(self, "ecs-devops-vpc", max_azs=3)

You can also use an existing vpc , if that is the case for you use the following lines:




vpc = ec2.Vpc.from_lookup(self, "ecs-devops-vpc",vpc_id='vpc-number')

For this, you need the vpc name and the corresponding id.

step 4: Cluster Creation :

With the vpc created we can attach the cluster to it . To create the cluster we can use the following code :




cluster = ecs.Cluster(self,

"ecs-devops-cluster",

cluster_name="ecs-devops-cluster",

vpc=vpc)

step 5: Creating the Role:

Let us create the role, the role will give the service permission to perform tasks.




execution_role = iam.Role(self, "ecs-devops-execution-role", assumed_by=iam.ServicePrincipal("ecs-tasks.amazonaws.com"), role_name="ecs-devops-execution-role")

With the execution role created we can attach policy to it to give it the permission it needs.




execution_role.add_to_policy(iam.PolicyStatement( effect=iam.Effect.ALLOW, resources=["*"], actions=["ecr:GetAuthorizationToken", "ecr:BatchCheckLayerAvailability", "ecr:GetDownloadUrlForLayer", "ecr:BatchGetImage", "logs:CreateLogStream", "logs:PutLogEvents"] ))

With the IAM role created we can attach a task definition to it

Step 6: Creating the task definition :

Here is the code we used to create the task definition ;




task_definition = ecs.FargateTaskDefinition(self, "ecs-devops-task-definition", execution_role=execution_role, family="ecs-devops-task-definition")

And the container :




container = task_definition.add_container("ecs-devops-sandbox", image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample") )

In the code above, we are initially specifying the Task Definition to run with an example container from a public AWS sample registry. This sample container is replaced with our application container when our CI/CD pipeline updates the Task Definition. We are using the container from the sample registry to allow the Service to stabilize before any application container images are added to our ECR repository.

With the task definition created we can attach a service that will be running it.

step 7: Creating the service :




service = ecs.FargateService(self, "ecs-devops-service", cluster=cluster, task_definition=task_definition, service_name="ecs-devops-service")

The service uses the task definition and you can see it is attached to our created cluster.

PS: When your AWS instance is in a public subnet , you need to auto-assign public IP addresses to the containers to grant them internet access. This will help your service to download a docker image from a public repository. In that case, you can use the following code when creating the service. :




service = ecs.FargateService(self,

"service-name",

cluster=cluster,

task_definition=task_definition,

service_name="service-name",

assign_public_ip=True, # this is important

security_groups=[list of security groups , also important],

vpc_subnets=[list of subnets]

)

Note the assign_public_ip , the security group and the VPC subnets.

Step 8: Creating the cloudwatch Log group:




log_group = aws_logs.LogGroup(



self,



"ecs-devops-service-logs-groups",



log_group_name="ecs-devops-service-logs")

As stated before we will be transferring the docker logs to our log group created in Cloudwatch.

With all the objects created let us make sure that we have all the ingredients for our stack in the following updated file.

ecs_devops_cdk/ecs_devops_cdk_stack.py




from aws_cdk import (core, aws_ecs as ecs, aws_ecr as ecr, aws_ec2 as ec2, aws_iam as iam, aws_logs)



class EcsDevopsCdkStack(core.Stack):

def __init__ (self, scope: core.Construct, construct_id: str, **kwargs) -> None:



super(). __init__ (scope, construct_id, **kwargs)

ecr_repository = ecr.Repository(self, "ecs-devops-repository", repository_name="ecs-devops-repository")

vpc = ec2.Vpc(self, "ecs-devops-vpc", max_azs=3)

cluster = ecs.Cluster(self, "ecs-devops-cluster", cluster_name="ecs-devops-cluster", vpc=vpc)

execution_role = iam.Role(self, "ecs-devops-execution-role", assumed_by=iam.ServicePrincipal("ecs-tasks.amazonaws.com"), role_name="ecs-devops-execution-role")

execution_role.add_to_policy(iam.PolicyStatement(

effect=iam.Effect.ALLOW, resources=["*"],

actions=["ecr:GetAuthorizationToken",

"ecr:BatchCheckLayerAvailability",

"ecr:GetDownloadUrlForLayer",

"ecr:BatchGetImage",



"logs:CreateLogStream",



"logs:PutLogEvents" ] ))



task_definition = ecs.FargateTaskDefinition(self, "ecs-devops-task-definition", execution_role=execution_role,

family="ecs-devops-task-definition")

container = task_definition.add_container("ecs-devops-sandbox", image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample"))

service = ecs.FargateService(self, "ecs-devops-service", cluster=cluster, task_definition=task_definition, service_name="ecs-devops-service")

log_group = aws_logs.LogGroup(self, "ecs-devops-service-logs-groups", log_group_name="ecs-devops-service-logs")

Before creating the stack open the file app.py

You should see something like this :




from aws_cdk import core

from ecs_devops_cdk.ecs_devops_cdk_stack import EcsDevopsCdkStack

app = core.App()



EcsDevopsCdkStack(app, "ecs-devops-cdk")

app.synth()

Replace the line where your stack is instantiated, 4th line, with the following :




EcsDevopsCdkStack(app, "ecs-devops-cdk", env={



'account': " **************",



'region': "your region"



})

With this set; you can now create your stack. With the code created we can now run the following command to create our stack.

cdk deploy

If everything goes well you should have your stack created. As a result, you will have a cluster, running a service that deploys a task definition, and a Cloudwatch log group created.

You can check your stack from the AWS console by navigating to the following link.

If you want, you can check this project on GitHub here.

That is all for this first part, we managed to build our ship and added the most important objects to it.

We are now ready to pack containers and deliver our content to our client.

In the second part of this series, we will learn how to convert our docker-compose file to a task definition described in this tutorial. See you then!

Hacktoberfest is almost there, Python developers here are some venues for parties.

Espoir Murhabazi — Wed, 30 Sep 2020 00:00:00 +0000

This year has been fantastic because I contributed to some open-source projects and had my pull request merged on amazing projects with many stars. It helps me to put some green dots on my GitHub profile…

I don’t want to brag about my open source contributions, which are very small compared to what has been done in the open-source community. Instead, I want to show you which open source project you can contribute to during this period. They are not the biggest parties at the festival, but they can train you to drink beers, dress, and dance before attending the most prominent venues.

By contributing to those projects, you can get those green dots on your GitHub profile so that when a recruiter asks you for some sample of your work, you can have something to show them.

But why October?

The reason why I wrote this post today, it’s because we are in October, which is the open-source month. DigitalOcean, in partnership with dev.to, organizes Hacktoberfest. During the most exciting open-source festival, people get the opportunity to contribute to open sources and get some swags and other awards for recognition.

Can you tell us about the venues? :

The venues are on Github. Here are some links with topics and descriptions of each venue I collected for you.

Kratec flask restful cookie-cutter

This project is a cookie-cutter, a template for creating flask applications.

It has a structured way to make flask-restful applications. It is a good starting point for building flask applications. It has some basic features all applications have in common such as token-based authentication and user management system.

It also has all the settings needed for a flask backend, such as database setup, celery configurations, docker-compose, etc.

Tech Stack:

The project is built using Flask and Python 3.6. If you are familiar with that stack, this can be a good start for you.

How You can contribute:

As for all the software projects, this one is not yet completed. It needs some improvements. You can make it PEP8 compliant by setting up linter to make sure it follows all the styles included in pep8. It has some open issues you can look to.

Masakhane :

This is my favorite project; it aims to apply the modern neural machine translation techniques to African languages. With this, we are building the next google translator for African languages. If you are an African, you care for African languages, and you are an NLP enthusiast, I will recommend to look at this project. It has a good opening community. You should join this project.

Tech stack used:

Python, Keras, PyTorch

How to Contribute:

The project is well documented; you can go to this section in the readme; you will find different ways to contribute.

We have a starter notebook, you can grab it, it is self-explanatory, and by running it for your local language, you can have the first benchmark for it.

PyTube :

This is a fantastic tool, and by contributing to it, you will be helping many developers around.From the project readme, you can read that:

PyTube is a very serious, lightweight, dependency-free Python library (and command-line utility) for downloading YouTube Videos.

In simple terms, this project helps you to download a Youtube video or a full Youtube playlist video by providing its URL using python code.

Tech stack used:

Python

How to contribute:

The project is looking for contributors. It has around 30 open issues as of now; you can pick one and start investigating it.I have opened this issue on the project. You can look at it. It is beginner-friendly, and if you have a beginner to intermediate knowledge in Python, you are good to go.

Chatistics

The project name is a concatenation of chat and statistics.It is a python3 project that converts chat logs from various messaging platforms into pandas DataFrames. It can also generate histograms and word clouds from the chat logs.Suppose you are an intermediate python developer who is interested in data, NLP, and text analysis. In that case, this can help you to forge your knowledge in those topics.It can help you find the most active users and get the most topics your friends discuss in a Whatsapp group or a telegram channel.

Tech stack used: Python

How to contribute:

The project has 18 open issues, and you can think about other features you can add. I have opened a issue about a feature some may need. You can look at it.

Speed Rwanda:

A few months ago, a friend of mine Remy Muhire started a twitter thread where Rwandans users could post their internet speed in text format and a screenshot of from fast.com.

We collected more than two hundred tweets from Rwandans.

They shared their network provider, their internet speed (in text and as a screenshot), and some shared their location.

Tech Stack:

Python, Tweepy, Pandas

How to contribute:

There are different ways to contribute to:

suppose you want to dive into optical character recognition. In that case, you can help us get the internet speed from the fast.com network speed screenshot.

If you want to get into data analysis, I have collected many questions you can answer using data visualization or simple pandas queries. You can check the project readme to learn more about it.

If you want to play with regex, you can also help us extract the tweets’ speed.

Pindo

Pindo is the communication platform for humans and machines. It helps to send messages, emails, and text in bulk. It’s similar to Nexmo or Twillo.

Tech Stack:

Python

How to contribute:

The project is actively looking for contributors. If you are a beginner and want to work on a CLI project, you can reach out to Remy Muhire. He can tell you how you can help.

Django-dotenv:

This project is a tool that helps to read .env files in a Django project.

Tech Stack:

Python and Django

How to contribute:

I have opened an issue. You can have a look at it to get started with the project.

Python and Django Conferences website (DjangoConf and EuroPython)

Other projects that can give you exposure are Django conference websites. The projects are written in Python and are maintained with the best Django developers in the world. Working on those projects can give you a kickstart in your Django learning path.

Tech Stack:

Python and Django

How to contribute:

Here is the link to the site also the EuroPython website, you can pick one project and see how you can help.

My Projects

I also have two open-source projects. I always hack on Github. Feel free to have a look at them, balobi nini, nzembo

Tech Stack:

Python, NLTK, Django, and soon Vue Js or React for frontend

How to contribute:

Reach out to me, and I will tell you how you can contribute.

StackOverflow Questions

Another way of contributing to open source is by answering questions on stack overflow. You will be surprised by the number of topics you can learn in a short period. I tried two years ago, and I was surprised by the number of people I have helped on the platform. Even today, people are still coming back to me to ask one or two questions about the answers I put there a long time ago.

Tech Stack:

You decide and choose what is familiar to you.

How to contribute:

I know most of you have never seen the stackOverflow home page; this is the chance to go and see it.

There are always beginners who ask for help. You can filter new questions according to the language and tech stack you are familiar with and provide service to people.

I don’t know how to dress and how to drink. Can you give us some links to get started?

You are not alone, we have all been there looking for how to take our first short. Luckily, we wrote some blogs post on how to get started.
I know someone who gave talks about opens source contributions. I would recommend to check out her @isabelcmdcosta. She wrote an amazing blog on how to overcome blockers while contributing to open sources projects

Here are other resources you can use :

How being drunk with pull requests and merge requests will help us?

We know that contributing to open source can play an instrumental role in your tech career. I could write a full blog post explaining its benefits, but that is for next time. And since we got a lot from the open-source community, contributing to open sources is an excellent way to give back to the community.

“YOU received free, give free.” Matthew 10:8

I have a not listed venue. How can I get people joining my stand?

If you have any other open-source project you know a beginner may be interested in, please share it with us.

Quelques meilleurs conseils pour un travail efficace à distance: une réalité africaine

Espoir Murhabazi — Thu, 26 Mar 2020 00:00:00 +0000

Photo Aeriènne de Goma, Crédit : Clarice Butsapu Twitter

De nos jours travailler à la maison est devenue une nécessité, étant développeurs c'est la seule façon de travailler en cette période de crise de la pandémie.

En parcourant l’internet, je n’ai pas pu trouver un bon article donnant certaines astuces pour le travail à distance dans le contexte Africain et précisément Congolais.En Afrique dans certains pays, avoir un bon internet et un courant stable est un dilemme de tout le jour.

Une idée, une motivation qui m’a poussé à rédiger cet article enfin de partage avec vous.

Dans cet article je partagerai mon expérience ainsi que les différentes leçons apprises durant mes quatre années de travail à la maison et j’espère pouvoir aider certains amis et petits frères et sœurs qui ont les mêmes problèmes.

Mais avant tout, laissez-moi me présenter : Je suis Espoir Murhabazi développeur FullStack indépendant avec une expérience de travail à distance que les anglais appelé “Remote work”.

Je vais d’abord, en premier lieu, dans cet article définir le terme télétravail ou Remote Work et après, présenter ses avantages.Le télétravail est une combinaison de deux mot télé et travail. Télé comme dans télévision, téléphone veut dire à distance; En terme plus simple le télétravail veut dire travailler à distance.

Wikipédia définit comme : Le télétravail, ou telecommuting en anglais, est une activité professionnelle effectuée en tout ou partie à distance du lieu où le résultat du travail est attendu. Il s’oppose au travail sur site, à savoir le travail effectué dans les locaux de son employeur. Le télétravail peut s’effectuer depuis le domicile, un télécentre, un bureau satellite ou de manière nomade (lieux de travail différents selon l’activité à réaliser), dans le cadre du travail salarié, mais aussi depuis des espaces partagés (coworking), dans le cadre du télétravail indépendant.

Les professionnels ne devraient pas attendre COVID-19 pour constater les avantages du télétravail, L’indépendance, Un gain de temps, Hausse de la qualité de vie, Une meilleure conciliation entre le travail et la vie de famille, Réduction de frais pour l’entreprise, Personnes handicapées.

Mais aussi le télétravail est trop lucratif pour les développeurs qui travaillent depuis les pays africains car il nous permet d’être rémunéré aux standards internationaux tout en vivant dans nos pays africains où le coût de la vie reste relativement faible.

Comment cela est-il possible ?

Actuellement avec internet et téléphonie nous pouvons être en contact avec des personnes de l’autre bout du monde dans un clic.Le monde professionnel utilise les outils comme Slack, Zoom, Skype pour nous permettre de créer des bureaux virtuels où d’espace de travail collaboratif qui ne nécessite pas la présence physique.Nous avons compris au moins l’apport de télétravail, passons maintenant à sur quelques astuces pour survivre dans le monde de travail à distance.

Astuces pour survivre

Avoir toujours une bonne connexion internet

Vendeur des Megas à Kinshasa Source : RFI

Comme pour télétravailler nous avons besoin d’une bonne connection internet , c’est donc la première chose que nous devons nous rassurer de ne pas manquer. Ce n’est pas professionnel de donner à ses collègues des prétextes de manque de connexion internet, ou de la lenteur de la connexion pour n’avoir pas fini le travail à faire. Toutes ces excuses n’ont pas leur place dans le monde professionnel. C’est du bulshit.

Le meilleur moyen de contourner cela, c’est de se préparer en avance en calculant avec exactitude la quantité des forfaits internet que l’on dépense mensuellement afin cherchez un fournisseur d’accès Internet avec la meilleure offre qualité-prix.

Il est également conseillé d’avoir au moins 2 ou 3 fournisseurs de relaie, car en cas d’urgence il est possible d’utiliser toutes les connexions en même temps. J’ai moi-même l’expérience d’avoir été contraint d’utiliser à la fois les connexions Airtel, Orange, MTN Rwanda et Airtel Rwanda.

Accès à l’électricité

Delestages en Afrique

Dans certains pays, l’électricité n’est plus du tout un problème sérieux; la population a facilement de l’électricité 24 heures sur 24; dans d’autres pourtant cela reste encore un sérieux problème d’actualité.Tout comme pour l’internet, il est évident que vos collègues ne prendront jamais en compte des excuses de délestage ou de manque d’énergie pour cause du retard de travail.

Voici donc quelques astuces pour palier à ce problème :

Investir dans un laptop ayant une bonne autonomie de la batterie. Il n’est pas nécessaire d’avoir le tout dernier macbook pro pour bien travailler, les chinois nous ont facilité la tâche avec de très bonnes batteries performantes à moindre coût.
Comme pour l’accès à internet, il faut avoir des alternatifs pour les sources d’électricité, l’investissement dans un kit solaire avec batteries pourrait rassurer quelques heures d’autonomie. Nos amis Nigérians utilisent des groupes électrogènes et ça marche bien chez eux.
Repérer des endroits calmes dans son entourage où l’on peut facilement avoir accès au courant et à internet, telle qu’une bibliothèque, un cyber café, un resto ou bar, etc. L’endroit peut ne pas être fancy ou chic mais juste une place où l’on peut s’asseoir confortablement et travailler calmement.

Une fois que les problèmes d’électricité et d’internet seront résolus, la moitié des problèmes que les jeunes africains rencontrent pour le remote work aura été résolu.Le reste d’astuces sont valables peu importe le pays où l’on travaille :

Avoir un endroit confortable où l’on peut s’asseoir tranquillement et coder :

Me Working from Somewhere in Kigali

Le télétravail donne la flexibilité de travailler n’importe où , mais tous les endroit ne favorisent pas la productivité .Personnellement j’ai tendance à somnoler si je travaille sur mon lit ou sur le fauteuil de mon salon, mais je me concentre beaucoup plus si je suis assis confortablement sur ma table de bureau .Nous n’avons pas besoin d’exigence pour ce qui est de la marque de la chaise ou de son prix pour travailler, il nous faut tout simplement un espace qui nous facilite de travailler convenablement; nous avons des très bons menuisiers qui peuvent nous fabriquer des chaises confortable à moins de 50 USD.

Éviter les distractions inutiles de la maison

Working from home and having family life.
Source : Bbc

Je pense que c’est la partie la plus difficile à gérer surtout lorsque l’on travaille à la maison et que des enfants ou de petits frères veuillent tout le temps s’amuser avec nous pendant que nous sommes disponible à tout moment.

La solution réside dans l’anticipation, informer les gens que tu es occupé et les éduquer à respecter tes heures de travail.

Au départ ils prendront sûrement du temps pour s’adapter mais après un bon moment ils s’habitueront à votre horaire, ainsi ils sauront qu’à tel ou tel autre moment de la journée, le papa ou le frère ou encore la soeur travaille et il ne veut pas être dérangé.

Investir dans de bons equipments audio:

Comme le travail à distance demande de passer la plupart du ton temps à appeler des collègues via Skype, Zoom ou autre application, un tres bon equipement audio s’avère important.

Des très bons écouteurs avec un bon micro aideront à bien parler avec ses collègues et toujours être professionnel lors des appels.Elles aideront également à s’isoler dans un endroit où il y a trop de monde et à éviter les dérangements inutiles.

Nous n’avons pas besoin d’avoir le tout dernier Airpods pro ou les derniers écouteurs Bose, à moins de 10 ou 20 $, nous pouvons obtenir des très bons écouteurs avec un bon microphone.

Avoir une vie Sociale

Me having a life at Gisenyi Beach

Un très grand problème avec le remote work est l’isolement social. A force de passer la plupart du temps à travailler à la maison, il y’a risque d’oublier la vie sociale. Une conséquence à long terme est la dépression. Croyez moi la dépression est réelle, je me rappelle avoir quitté mon remote work parce que je me suis retrouvé seul sans collègues et déprimé.

Pour pallier à cela voici certains astuces que je vous suggère:

Mettre des limites entre les heures de travail et les heures de repos, d’habitude si je commence à travailler à 9h je m’efforce à tout finir à 21h . Car je sais que mon cerveaux ne se concentre pas au delà de 21 même les grands bugs savent qu’ils ne peuvent pas être résolus à cette heure.
Trouve toi une activité extra professionnelle : personnellement j’aime le foot et la première league, mes week-ends sont pour le football et ainsi je vais dans la ville et je m’amuse avec les amis.
C’est aussi bien de trouver un club qui peut être de lecture ou de n’importe quoi mais ou les gens se retrouvent régulièrement physiquement pour discuter des sujets qui importent pour eux.Personnellement l’Église et la Religion m’aident car je sais que mes dimanches sont réservés à Dieu, je pars au culte, j’ai des amis, on rigole un peu et on oublie les soucis de la vie.
Avoir une petite amie peut aussi aider, comme soutien émotionnel

Prend soin de ton corps.

Un esprit sain dans un corps sain.

Les media et les films nous ont vendu l’idée que le geek c’est une personne qui es gros et qui passe sont temps à coder, manger la pizza et boire du coca. Mes chers amis, c’est juste une idée reçu et dans la plupart du temps, c’est faux.

Aie une bonne hygiène de vie, moi personnellement je commence ma journée par 30 push ups et 30 abdominaux. L’important n’est pas le nombre mais la répétition et la constance dans ces habitudes.A me voir je suis aussi slim que Wizzy Calipha mais ça m’aide à garder la forme.

Selon ton programme, prends le temps de préparer un bon petit déjeuner et un bon dîner ou si tu vis avec la famille, prends le temps de savourer la nourriture de maman ou de ton partenaire.

Rappelle toi: ventre creux n’a point d’oreil

Local Food Credit: Esther Nsapu on Twitter

Les autres astuces en rapport au professionnalisme dans le monde réel reste aussi valable en remote work :

La ponctualité a toujours sa place, toujours bon de se connecter 10 minutes dans un appel zoom pour éviter les soucis technique et être toujours la personne qu’on attend dans un call.
Comme la communication se passe par écrit, c’est toujours bon d’éviter de faire des fautes d’orthographe, d’être clair et concis dans ses communications écrites (mails ou slack messages).
Etc…

Celles-là ne sont que quelques astuces que j’ai pu trouvé. Vous n’êtes pas obligé(e) de les suivre à la lettre, ils ont marché pour moi mais ne marcheront peut être pas pour vous, avec quelques révisions et ajustements vous pouvez avoir une version valide pour vous.Mais je suis sur qu’il y en a plein qui marchent avec vous , n’hésitez pas à nous le faire savoir en commentaire.

Big thanks à tous le monde qui a participé de pret ou de loin à la rédaction cet article : Ma petite soeur Ndeze Josephine, mon grand Bosco B, Karl Musingo, Brian pour les corrections et suggestions.

In meantime: Take care, Stay Home, Stay Safe, and don't forget to always wash your hands...