Nuwae

nuwae

Startups of The Year 2023 Winners: North America 

Ensuring Reproducibility in AI Research: Code and Pre-trained Weights Open-Sourced

Startups of The Year 2023 Winners: Europe

A Journey to the Center of the Earth by Jules Verne, is part of the HackerNoon Books Series. You can jump to any chapter in this book . THE MYSTERIOUS PARCHMENT here CHAPTER II - THE MYSTERIOUS PARCHMENT "I declare," cried my uncle, striking the table fiercely with his fist, "I declare to you it is Runic—and contains some wonderful secret, which I must get at, at any price." I was about to reply when he stopped me. "Sit down," he said, quite fiercely, "and write to my dictation." I obeyed. "I will substitute," he said, "a letter of our alphabet for that of the Runic: we will then see what that will produce. Now, begin and make no mistakes." The dictation commenced with the following incomprehensible result: mm.rnlls esruel seecJde sgtssmf unteief niedrke kt,samn atrateS Saodrrn emtnaeI nuaect  rrilSa Atvaar  .nscrc  ieaabs ccdrmi  eeutul  frantu dt,iac  oseibo  KediiY Scarcely giving me time to finish, my uncle snatched the document from my hands and examined it with the most rapt and deep attention. "I should like to know what it means," he said, after a long period. I certainly could not tell him, nor did he expect me to—his conversation being uniformly answered by himself. "I declare it puts me in mind of a cryptograph," he cried, "unless, indeed, the letters have been written without any real meaning; and yet why take so much trouble? Who knows but I may be on the verge of some great discovery?" My candid opinion was that it was all rubbish! But this opinion I kept carefully to myself, as my uncle's choler was not pleasant to bear. All this time he was comparing the book with the parchment. "The manuscript volume and the smaller document are written in different hands," he said, "the cryptograph is of much later date than the book; there is an undoubted proof of the correctness of my surmise. [An irrefragable proof I took it to be.] The first letter is a double M, which was only added to the Icelandic language in the twelfth century—this makes the parchment two hundred years posterior to the volume." The circumstances appeared very probable and very logical, but it was all surmise to me. "To me it appears probable that this sentence was written by some owner of the book. Now who was the owner, is the next important question. Perhaps by great good luck it may be written somewhere in the volume." With these words Professor Hardwigg took off his spectacles, and, taking a powerful magnifying glass, examined the book carefully. On the fly leaf was what appeared to be a blot of ink, but on examination proved to be a line of writing almost effaced by time. This was what he sought; and, after some considerable time, he made out these letters: "Arne Saknussemm!" he cried in a joyous and triumphant tone, "that is not only an Icelandic name, but of a learned professor of the sixteenth century, a celebrated alchemist." I bowed as a sign of respect. "These alchemists," he continued, "Avicenna, Bacon, Lully, Paracelsus, were the true, the only learned men of the day. They made surprising discoveries. May not this Saknussemm, nephew mine, have hidden on this bit of parchment some astounding invention? I believe the cryptograph to have a profound meaning—which I must make out." My uncle walked about the room in a state of excitement almost impossible to describe. "It may be so, sir," I timidly observed, "but why conceal it from posterity, if it be a useful, a worthy discovery?" "Why—how should I know? Did not Galileo make a secret of his discoveries in connection with Saturn? But we shall see. Until I discover the meaning of this sentence I will neither eat nor sleep." "My dear uncle—" I began. "Nor you neither," he added. It was lucky I had taken double allowance that day. "In the first place," he continued, "there must be a clue to the meaning. If we could find that, the rest would be easy enough." I began seriously to reflect. The prospect of going without food and sleep was not a promising one, so I determined to do my best to solve the mystery. My uncle, meanwhile, went on with his soliloquy. "The way to discover it is easy enough. In this document there are one hundred and thirty-two letters, giving seventy-nine consonants to fifty-three vowels. This is about the proportion found in most southern languages, the idioms of the north being much more rich in consonants. We may confidently predict, therefore, that we have to deal with a southern dialect." Nothing could be more logical. "Now," said Professor Hardwigg, "to trace the particular language." "As Shakespeare says, 'that is the question,"' was my rather satirical reply. "This man Saknussemm," he continued, "was a very learned man: now as he did not write in the language of his birthplace, he probably, like most learned men of the sixteenth century, wrote in Latin. If, however, I prove wrong in this guess, we must try Spanish, French, Italian, Greek, and even Hebrew. My own opinion, though, is decidedly in favor of Latin." This proposition startled me. Latin was my favorite study, and it seemed sacrilege to believe this gibberish to belong to the country of Virgil. "Barbarous Latin, in all probability," continued my uncle, "but still Latin." "Very probably," I replied, not to contradict him. "Let us see into the matter," continued my uncle; "here you see we have a series of one hundred and thirty-two letters, apparently thrown pell-mell upon paper, without method or organization. There are words which are composed wholly of consonants, such as , others which are nearly all vowels, the fifth, for instance, which is unteief, and one of the last oseibo. This appears an extraordinary combination. Probably we shall find that the phrase is arranged according to some mathematical plan. No doubt a certain sentence has been written out and then jumbled up—some plan to which some figure is the clue. Now, Harry, to show your English wit—what is that figure?" mm.rnlls I could give him no hint. My thoughts were indeed far away. While he was speaking I had caught sight of the portrait of my cousin Gretchen, and was wondering when she would return. We were affianced, and loved one another very sincerely. But my uncle, who never thought even of such sublunary matters, knew nothing of this. Without noticing my abstraction, the Professor began reading the puzzling cryptograph all sorts of ways, according to some theory of his own. Presently, rousing my wandering attention, he dictated one precious attempt to me. I mildly handed it over to him. It read as follows: mmessunkaSenrA.icefdoK.segnittamurtn ecertserrette,rotaivsadua,ednecsedsadne lacartniiilrJsiratracSarbmutabiledmek meretarcsilucoYsleffenSnI. I could scarcely keep from laughing, while my uncle, on the contrary, got in a towering passion, struck the table with his fist, darted out of the room, out of the house, and then taking to his heels was presently lost to sight. About HackerNoon Book Series: We bring you the most important technical, scientific, and insightful public domain books. This book is part of the public domain. Jules Verne (2006). A Journey to the Center of the Earth. Urbana, Illinois: Project Gutenberg. Retrieved October 2022 https://www.gutenberg.org/files/18857/18857-h/18857-h.htm This eBook is for the use of anyone anywhere at no cost and with almost no restrictions whatsoever. You may copy it, give it away or re-use it under the terms of the Project Gutenberg License included with this eBook or online at , located at . www.gutenberg.org https://www.gutenberg.org/policy/license.html

THE MYSTERIOUS PARCHMENT

277 Stories To Learn About Microservices

274 Stories To Learn About Code Quality

Crypto Crash? Not Really... 

As a data scientist, I have given and conducted lots of job interviews. I would like to point out that they are not like traditional computer science interviews with algorithmic tasks you can practice on Leetcode and Hackerrank. Typically data scientists are given tasks to build a machine learning model on some dataset, meaning that there is no exact solution. Any solution is just an approximation, and you never know the threshold of accuracy that the interviewer will be satisfied with. Learning GAN from Scratch Also, a trend that I have noticed over the last five years of going through data science interviews is that the complexity of the tasks grows. For example, several years ago, logistic regression or simple multilayer perceptron for binary classification was enough to qualify. Nowadays, knowledge of more advanced techniques is required. For example, building a generative adversarial network (GAN) from scratch or training an image recognition neural net using triplet loss, or training a ML model capable of classifying images of open and closed human eyes without any annotation. This can help in sleepy driver detection in modern cars, while that lack of annotation is a real case as well since annotation either costs money or takes a long, to obtain or in some cases, even impossible to get due to privacy protection. Let’s take a deeper look at this task and its solution by the author of this article, which will help you be more prepared for interviews for a data scientist position. The formulation of the task goes like this: given a dataset of images of human eyes and no annotation, train a model that can classify images with as high accuracy as possible. The trained model must allow being tested with a python script on a hold-out dataset. The deadline for this task was 24 hours. So let’s waste no time and hop onto it right away. First, we need to figure out where to code: in a Jupyter notebook or an IDE like PyCharm. Why the dilemma? The easiest way is to go with a notebook since it allows easy data exploration and nice in-place visualizations of images and graphs. However, eventually, we have to provide a python script that will test the model. At his point we would like to reuse a part of the code from the training notebook with is not that easy. The approach that I practice is to start coding in a notebook, then once the code and the model become stable, copy the code to a python script and scrap the notebook for good to avoid the loss of synchronization between the script and the notebook. Images Initial data exploration shows that we are given 3600 grayscale images of resolution 24x24, some having on them a single eye open, some - closed. We could theoretically manually annotate all 3600 images, and it would take something like an hour, but there will be little prestige in going with this brute force approach of manual labor. If only we could annotate just a handful of samples and apply some techniques of semi-supervised learning to get high accuracy… Oh, actually, we can! The classical scheme of semi-supervised learning is to train a model in two stages: the first one being an autoencoder and the second one being a linear classifier built on top of the output of the encoder. Why is this scheme? See, if we were to train a classification model on just several samples (10-100) there is a high chance that any neural network will overfit on the train set since the size of the feature is 24*24=576 numbers. However, if we could reduce the dimensionality of the feature to a smaller value, say 50, we could avoid the overfit. Dimensionality can be reduced with PCA for example but in this case, we are not quite sure that the signal about open/closed eyes isn’t discarded by PCA. Another method of “smart” dimensionality reduction is an autoencoder, that first compresses the image to a latent vector of a specified size (50 in our case) and then decompresses it to recover the original image. We are going to talk about autoencoders being a neural net, of course. A traditional autoencoder should be able to learn the embedding of the original native representation of the contents of the image (eye open/shut, multiple features describing the style of the eye, maybe up to person’s physiology like the depth of an eye orbit, iris diameter, etc). However, the individual components may be quite entangled. There is a type of autoencoder called variational autoencoder [1] that can disentangle features and in our case facilitate our target task - classification. Let’s create a VAE in PyTorch. We are going to use 4 layers and 2 full-connected layers with our distributions’ mean and variance predictions, each being a vector with the length of the latent space size. The decoder will be a sequence of 4 to reconstruct the image back from the latent representation. Note in we apply the re-parametrization trick to make the VAE end-to-end differentiable. Conv2D ConvTranspose2d VAE.forward() class NormalizedOp(nn.Module):
    def __init__(self, op):
        super().__init__()
        self.op = op
        self.bn = nn.BatchNorm2d(op.out_channels)

    def forward(self, x):
        x = self.op(x)
        x = self.bn(x)
        return x


class Encoder(nn.Module):
    def __init__(self, latent_size):
        super().__init__()
        self.conv1 = NormalizedOp(nn.Conv2d(1, 32, 3, padding=1, stride=2))
        self.conv2 = NormalizedOp(nn.Conv2d(32, 64, 3, padding=1, stride=2))
        self.conv3 = NormalizedOp(nn.Conv2d(64, 128, 3, padding=1, stride=2))
        self.conv4 = NormalizedOp(nn.Conv2d(128, 256, 3, padding=0, stride=3))

        self.mu_fc = nn.Linear(256, latent_size)
        self.log_var_fc = nn.Linear(256, latent_size)

    def forward(self, x):
        x = torch.relu(self.conv1(x))
        x = torch.relu(self.conv2(x))
        x = torch.relu(self.conv3(x))
        x = torch.relu(self.conv4(x))
        x = x.view(x.shape[0], -1)

        mu = self.mu_fc(x)
        log_var = self.log_var_fc(x)
        return mu, log_var


class Decoder(nn.Module):
    def __init__(self, latent_size):
        super().__init__()

        self.dec_fc = nn.Linear(latent_size, 256)

        self.tconv1 = nn.ConvTranspose2d(256, 128, 3, padding=0, stride=3)
        self.tconv2 = nn.ConvTranspose2d(128, 64, 3, output_padding=0, stride=2)
        self.tconv3 = nn.ConvTranspose2d(64, 32, 3, output_padding=0, stride=2)
        self.tconv4 = nn.ConvTranspose2d(32, 1, 3, output_padding=0, stride=2)

    def forward(self, z):
        x = self.dec_fc(z)

        x = x.unsqueeze(-1).unsqueeze(-1)
        x = torch.relu(self.tconv1(x))
        x = torch.relu(self.tconv2(x))[:, :, :-1, :-1]
        x = torch.relu(self.tconv3(x))[:, :, :-1, :-1]
        x = torch.sigmoid(self.tconv4(x))[:, :, :-1, :-1]

        return x


class VAE(nn.Module):
    def __init__(self, latent_size):
        super().__init__()

        self.encoder = Encoder(latent_size)
        self.decoder = Decoder(latent_size)

    def forward(self, x):
        mu, log_var = self.encoder(x)

        std = torch.exp(log_var / 2)
        q = torch.distributions.Normal(mu, std)
        z = q.rsample()

        x = self.decoder(z)

        return x, z, mu, std Training Variational Autoencoders (VAE) Now we need to train our VAE on the entire dataset of 3600 eye images. The most important thing here is the loss function. It consists of the reconstruction loss which is Mean Squared Error (MSE) in our case and a KL-divergence loss. The KL-divergence term penalizes the discrepancy between the estimated Gaussian distribution parameters and a multivariate N(0, 1) Gaussian distribution. def kl_divergence(mu, std):
    kl = (std**2 + mu**2 - torch.log(std) - 1/2).mean()
    return kl


class VaeTrainer:
    def __init__(self, latent_size):
        self.vae = VAE(latent_size=latent_size)
        self.vae.cuda()

    def train(self):
        self.vae.train()

        image_list, _ = load_archive()
        tensor_data = (1 / 255 * torch.tensor(image_list).float()).unsqueeze(1)
        dataset = torch.utils.data.TensorDataset(tensor_data)
        loader = torch.utils.data.DataLoader(dataset, batch_size=256,
                                             shuffle=True, num_workers=0)
        optimizer = torch.optim.Adam(self.vae.parameters(), lr=1e-2)

        num_iters = 10_000
        i_iter = 0
        while i_iter < num_iters:
            for i_batch, (batch,) in enumerate(loader):
                batch = batch.cuda()
                pred_batch, z_batch, mu_batch, std_batch = self.vae(batch)
                optimizer.zero_grad()
                loss_recon = F.mse_loss(batch, pred_batch)
                loss_kl = kl_divergence(mu_batch, std_batch)
                loss = loss_recon + 0.001*loss_kl
                loss.backward()
                optimizer.step()
                if i_iter % 100 == 0:
                    print(i_iter, loss_recon.item(), loss_kl.item(), loss.item())
                    torch.save(self.vae.state_dict(), "vae.pth")
                i_iter += 1 Once we’ve trained the VAE to convergence, we can take a look at what the reconstructed images look like: The reconstruction is performed pretty well considering the latent vector size of just 50 elements. Also, due to the information bottleneck created by the latent vector, the noise in the images is filtered away. At this point, we have a model train in an unsupervised manner. However, the end goal is open/shut classification. We still need to manually annotate the data. I’ve picked as few as 50 open-eye and 50 shut-eye images and annotated them. Let’s check what accuracy we can achieve with just 40 annotated images. Below is the classifier code which is a frozen pre-trained encoder and a full-connected layer with a single output on top of it. class Classifier(nn.Module):
    def __init__(self, latent_size, pretrained_model_path="vae.pth"):
        super().__init__()
        self.encoder = Encoder(latent_size)
        self.freeze_backbone = pretrained_model_path is not None
        if pretrained_model_path is not None:
            state_dict = torch.load(pretrained_model_path)
            state_dict = OrderedDict(((k[len("encoder."):], v)
                                     for k, v in state_dict.items()
                                      if "encoder." in k))
            self.encoder.load_state_dict(state_dict, strict=True)
            for param in self.encoder.parameters():
                param.requires_grad = False
        self.encoder.eval()
        self.class_fc = nn.Linear(latent_size, 1)

    def forward(self, x):
        with torch.no_grad() if self.freeze_backbone \
                else contextlib.nullcontext():
            mu, log_var = self.encoder(x)
        logits = self.class_fc(mu)
        x = torch.sigmoid(logits)
        x = x.squeeze(-1)
        return x

    def train(self, mode=True):
        self.encoder.train(False)
        self.class_fc.train(mode) The Training Process The training process is very similar though we train the head’s fully connected layer only and we can do significantly fewer iterations. Also, please notice that we train based on the number of iterations, not the number of epochs. This is convenient when the dataset size is a hyperparameter itself. We are free to make it larger by annotating more images. Still, normally you want your training cycle to consist of a fixed number of iterations. Thus we limit iterations, not epochs. class ClassifierTrainer:
    def __init__(self, latent_size, from_scratch=False):
        self.model = Classifier(
            latent_size,
            **(dict(pretrained_model_path=None)
               if from_scratch else {}))
        self.model.cuda()
        self.prediction_threshold = 0.5

    def _load_dataset(self, is_train):
        anno_images = ... # Hidden for the sake of saving space
        images_np = np.array(anno_images)
        images_np = 1 / 255 * np.expand_dims(images_np, 1)
        anno_np = np.array([v[1] for v in flat_list])
        dataset = torch.utils.data.TensorDataset(
            torch.tensor(images_np, dtype=torch.float32),
            torch.tensor(anno_np, dtype=torch.float32))
        return dataset

    def train(self):

        train_dataset = self._load_dataset(True)
        val_dataset = self._load_dataset(False)

        train_loader = DataLoader(train_dataset, batch_size=len(train_dataset),
                                  shuffle=True, num_workers=0, drop_last=True)
        val_loader = DataLoader(val_dataset, batch_size=len(val_dataset),
                                shuffle=False, num_workers=0, drop_last=True)

        all_params = list(self.model.parameters())
        print("len(all_params)", len(all_params))

        optimizable_params = [p for p in self.model.parameters() if p.requires_grad]
        print("len(optimizable_params)", len(optimizable_params))
        optimizer = torch.optim.Adam(optimizable_params, lr=1e-2, weight_decay=2e-5)

        num_iters = 5_000
        i_iter = 0
        while i_iter < num_iters:
            for i_batch, (image_batch, anno_batch) in enumerate(train_loader):
                self.model.train()
                image_batch = image_batch.cuda()
                anno_batch = anno_batch.cuda()
                pred_batch = self.model(image_batch)
                optimizer.zero_grad()
                loss = F.binary_cross_entropy(pred_batch, anno_batch)
                loss.backward()
                optimizer.step()

                hard_pred_batch = pred_batch > self.prediction_threshold
                anno_bool_batch = anno_batch > self.prediction_threshold
                if i_iter % 1000 == 0:
                    print(i_iter, " train_loss=", loss.item())
                    accuracy = torch.sum(torch.eq(hard_pred_batch, anno_bool_batch)) \
                               / len(anno_bool_batch)
                    print("train_accuracy=", accuracy.item())
                    self._validate(val_loader)
                    torch.save(self.model.state_dict(), "classifier.pth")
                i_iter += 1

        print("weight=", self.model.class_fc.weight.data)
        print("bias=", self.model.class_fc.bias.data)

    def _validate(self, val_loader):
        self.model.train(False)
        image_batch, anno_batch = next(iter(val_loader))
        image_batch = image_batch.cuda()
        anno_batch = anno_batch.cuda()
        with torch.no_grad():
            pred_batch = self.model(image_batch)
            loss = F.binary_cross_entropy(pred_batch, anno_batch)
        print("val_loss=", loss.item())
        hard_pred_batch = pred_batch > self.prediction_threshold
        anno_bool_batch = anno_batch > self.prediction_threshold
        accuracy = torch.sum(torch.eq(hard_pred_batch, anno_bool_batch)) / \
                   len(anno_bool_batch)
        print("val_accuracy=", accuracy.item()) Results Now we are able to train our classifier from scratch and compare it side-by-side with the finetuned version to figure out how much of an improvement we can get. The validation accuracy for the model trained from scratch to convergence turns out to be 78%. Finally, the VAE pretrained model gives us ! This is a clear success of VAE-based unsupervised pretraining since going from 78% to 94% accuracy of binary classification is basically going from a useless model to a useful one. as high accuracy as 94% This is achieved with as few as 50 training samples (the other 50 were used for validation). At the same time as a byproduct, we’ve got a generative model which is capable of generation of non-existent eye images, which may be used for the purposes of data augmentation or even privacy protection. The entire code of this article is available at my GitHub: . https://github.com/Obs01ete/eyes Check out my personal page: . https://obs01ete.github.io/ Reference: Variational autoencoder paper https://arxiv.org/abs/1312.6114 Closed Eyes In The Wild (CEW) dataset http://parnec.nuaa.edu.cn/_upload/tpl/02/db/731/template731/pages/xtan/ClosedEyeDatabases.html

Variational Autoencoders (VAE): How AI Learns Whether Your Eyes Are Open Or Closed

The book Microservices Security in Action , which I authored with Nuwan Dias is now available to buy online from Amazon and Manning . Nuwan and I spent last 27+ months writing/re-writing the book. It was a marathon effort, but yet a great experience, and we both are very glad to see how it came out at the end! This is the story, which lead us to write the book. While working at WSO2 for more than a decade, we’ve seen how the integration domain evolved over time from SOAP-based services to JSON/RESTful services and then to microservices. We spent most of our early days at WSO2 contributing to the Apache Axis2 project, which was a popular SOAP engine in those days, and to the Apache Rampart project, which implements many Organization for the Advancement of Structured Information Standards (OASIS) standards for web services security. Even though SOAP was quite promising in those days, it started to fade rapidly over time, and clearly JSON/RESTful services had won. Most of the microservice implementations we see today follow RESTful design principles. In the last two to three years, we’ve seen a genuine interest from many companies we’ve worked with to move into microservices architecture, and projects starting from scratch are adopting microservices principles. Most of the early adopters of microservices just wanted to get things done, and worried mostly about implementing functional requirements. They didn’t worry too much about security, although they should have. In many cases, securing microservices would mean securing the interactions among microservices with Transport Layer Security (TLS), and may be, for some, enforcing mutual TLS for service-to-service authentication. But none of them are quite adequate. There are two main reasons many didn’t worry much about security: complexity and awareness. Some time back, we found that most tools for securing microservices were not easy to use or couldn’t address the challenges specific to microservices deployments. This complexity was a barrier to securing microservices. At the same time, people who didn’t put much effort into security weren’t fully aware of the risks. We started hearing these stories from many of our customers as well as from the extended open source community we work with. That motivated us to write this book on securing microservices. Bringing an idea from inception to reality takes considerable time and effort. We lived with this idea of writing a book for more than two years until Manning reached out to us. During that period, with the increased adoption of microservices, the infrastructure around microservices security also evolved. Writing a book about a rapidly evolving domain is bit of a challenge; you never know when your book will be obsolete. After discussing this challenge with the publisher, we decided to put more weight on principles and patterns, and use tools just to demonstrate how to apply those principles and patterns in practice. This was our ground rule in picking up the technology stack for the book. We use Spring Boot / Java to develop all the samples, though we don’t expect you to know either Java or Spring Boot in detail. If you have development experience in any programming language, you should be able to follow all the samples in the book with no difficulty. Security itself is a larger domain. Securing microservices can mean different things to different people, based on their experiences and expectations. This fact was highlighted by one of the reviewers of the book, who comes from a security testing background. In our book, we wanted to focus on managing access to microservices. In other words, we wanted to focus on securing access to microservices with authentication and authorization. So, the book doesn’t talk about protecting microservices against different types of attacks, such as SQL injection, cross-site scripting (XSS), cross-site request forgery, and so on. After a marathon effort that spanned slightly more than two years, we are glad to see that our book on microservices security is out. We are also excited that this is the very first book on securing microservices. We hope you will enjoy reading it! The book has five sections and 13 chapters. Part 1 takes you through the fundamentals in securing microservices: Chapter 1 teaches you why securing microservices is challenging, and takes you through the key principles in securing a microservices deployment. Chapter 2 teaches you how to build your first microservice in Spring Boot and secure it with OAuth 2.0. You will also learn how to set up an OAuth 2.0 token issuer. Part 2 takes you through securing a microservice at the edge (or entry point) in a typical microservices deployment: Chapter 3 takes you through the consumer landscape of your microservices and teaches you how to deploy a Spring Boot microservice behind the Zuul API gateway. You will also learn how to enforce OAuth 2.0-based security at the Zuul API gateway. Chapter 4 teaches you how to develop a single-page application (SPA) with Angular. You will also learn how to secure a SPA with OpenID Connect. Chapter 5 teaches you how to extend the use case you built in chapter 4 by engaging throttling, monitoring, and access control at the Zuul API gateway. Part 3 takes you through the process of securing interactions among microservices once a request from a client application passes through the security at the edge and enters into your microservices deployment: Chapter 6 teaches you how to secure communications among microservices that take place over HTTP, with mutual Transport Layer Security (mTLS). In chapter 7, you learn how to share contextual data (for example, the end user context) among microservices by using JSON Web Token (JWT). Chapter 8 teaches you how to secure communications among microservices that take place over gRPC, with mTLS and JWT. Chapter 9 teaches you how to secure reactive microservices. It also teaches you how to set up Kafka as a message broker, and how to enforce access-control policies for Kafka topics. Part 4 takes you through deploying and securing microservices in a containerized environment: Chapter 10 teaches you how to deploy your microservices in Docker and to secure service-to-service interactions with mTLS and JWT. You also learn some of the built-in security features related to Docker. Chapter 11 teaches you how to deploy your microservices as Docker containers in Kubernetes and to secure service-to-service communications with JWT over mTLS. Chapter 12 teaches you how to offload the security processing overhead from your microservices by using the Istio service mesh. Part 5 takes you through security testing in the development process: Chapter 13 teaches you how to automate security testing of your microservices with SonarQube, Jenkins, and OWASP ZAP. In general, you should be sure to read the first two chapters so that you have the right mindset to take on the challenges of securing microservices and that you’ve gotten your feet wet and are ready to build more complex security patterns, which the book teaches you. The appendices provide information on OAuth 2.0, JWT, gRPC, Docker, Kubernetes, Istio, Open Policy Agent (OPA), and SPIFFE. This information supplements the chapters.

Introducing Microservices Security in Action 

Online background screenings have increasingly grown in popularity over the years, with more and more people resorting to it to verify known details as well as to find out the unknown. The advantages of using a people search tool can extend from your personal life to the workplace – whether you are curious to find out more about someone you’ve just met online, or trying to verify details of a candidate you have interviewed at work, or suspecting fraudulent behavior by a new neighbor. However, these search efforts have mostly focused on people searches using reverse name lookups, with effective search results generated by several tools in particular. These range from search engines like that collate freely available online data, to websites specializing in background searches like that provide more in-depth and comprehensive reports. Google Nuwber However, did you know that reverse searches can be carried out on a whole range of content? The amount of content that could be searched is quite overwhelming and could be diverse in nature, from text and images to even sound clips. Technology has indeed opened up a vast digital world for us to explore. Below are 5 awesome types of reverse searches that could surprise you with the staggering amount of information you can uncover in a digitally connected world. Reverse address search Whether you are trying to find more about a particular business location or want to check out the neighbors of a new house you are interested in buying, there would be many occasions when you are left wondering what to do with only an address in hand. This is when a reverse address search could come to your rescue. Depending on which tools you use, a reverse lookup of an address could get you much more than a name. While you can go through county records to uncover ownership details of an address, there are far easier and less stressful ways to get the job done. The easiest way to search an address is by using a popular search engine like Google. While it’s free to use, Google could pull up all records that are available online that relate to the address you are searching for. It can also provide you with details of any profiles the address might be linked to, depending on the user’s privacy settings. However, be prepared to spend a significant amount of time searching through a long list of websites retrieved by the search engine. social media There are also several effective people search sites that offer reverse address lookups free of charge. These are an ideal choice if you want to save time and get all available details summarized in a report. These reports can be surprisingly comprehensive, although that type of detailed service would usually require a small payment. The information these background search sites can provide can range from contact numbers and property ownership details to their social media activity and even details of neighbors. Reverse email search From phishing attacks to fake requests for help, email scams are on the rise. The IRS reported a aimed at stealing money and tax data during 2018. This year, due to an email scam that triggered the change of account details for a fund transfer – an increasingly encountered scam, commonly known as a Business Email Compromise (BED). 60% increase in email scams a Toyota supplier lost $37 million Whether you are faced with a suspicious email or simply attempting to validate the authenticity of an email request, finding out the true identity behind an email address could save you from much trouble. This is exactly what a reverse email lookup does. It’s about retrieving personal details such as a name and a contact number with the help of nothing but an email address. An email verification tool such as can help you verify the accuracy and authenticity of an email address. However, a social media search or a search engine tool can get you access to more information. Social media sites, in particular, could provide you with access to more personal details if it’s linked to a profile, post or a comment, depending on the privacy settings. NeverBounce Social media sites have become a great platform for sharing especially bad personal encounters. So, if the email address you are searching for has been involved in any prior scams or frauds, for example, these can be uncovered easily through conversations in social media. Background search sites can also perform people searches using an email address. They use complex algorithms to get you a comprehensive set of details by accessing a vast network of information like social media platforms as well as public records and even criminal records. Reverse phone search According to the YouMail Robocall Index, were reportedly received by Americans during the first 10 months alone this year. Health-related robocall scams have jumped by 29 percent while interest rate-related ones have increased by 13 percent in October. The numbers are certainly disturbing and it seems spams and scams have become the new buzzwords. 49 billion robocalls From phone scams to prank calls and annoying telemarketers can all become good enough reasons for deciding to perform a reverse phone lookup. There are many free options available to help get you started, including Caller ID subscriptions and directory assistant services offered by your telecom operator. Downloading a caller identification app like Truecaller could be of particular use as it can help you identify the caller’s name and even location at times. These apps have access to impressive spam directory databases generated by users, which can at times exceed 1 billion in numbers. They can even help you identify messages as well as block spam calls. While the amount of information you can retrieve through these caller identification apps are limited, you can select a people search site if you require more in-depth information about the caller. These are especially useful when it comes to uncovering the identity of spam and nuisance calls or those you suspect of fraud. Apart from the basic personal details, these background screenings can uncover felonies, warrants as well as arrest records. They can even provide you with details of neighbors, immediate and extended family, property and vehicle ownership as well as bankruptcies and credit ratings. Reverse image search A reverse image lookup allows you to upload an image and carry out a search for related information that is available online. These details could range from a list of websites containing the image to different image sizes and similar images. This can be useful whether you are attempting to find more about someone you’ve met on a dating site or you are looking to credit the source of an image that you want to include in your blog. Search engines like Google are usually the first choice to carry out a reverse image lookup. On Google, for example, you can open the browser and click on the image tab on the top right corner to open the image search window. It will provide you with the option to upload an image or to paste an image URL to search. Once done, Google will sift through billions of images available online to provide you with the most relevant search results. Specialized sites like can also provide you with reverse image lookup features. The advantage of using these sites is that they are able to perform fast searches across a number of search engines like Google and Bing. This will provide you with improved results while saving you from the trouble of going through several search engines. DupliChecker You can also carry out an image search on your mobile device using several options. The Chrome app, for example, opens up a menu with “search Google for this image” option when you press on an online image that you would like to search for. You can use Google to directly upload an image from your phone by opening the Google search page in the desktop version. There are also many other free and paid apps available for download on app stores to help you perform reverse image lookups. Reverse Audio Search Is there a familiar tune buzzing in your head that you just can’t seem to put a name on? Have you ever been to a restaurant and heard an awesome piece of jazz music that you want to track down? Reverse audio lookup is an exciting service to explore audio content in moments like these by playing an audio clip or singing or humming a tune. While it is often used to search song clips, an audio search can also be quite useful for searching other audio content like podcasts and sound effects in commonly used formats. There are plenty of specialized search engines for audio content. Shazam is one of the popular apps for searching music content to check the song title, artist and other related music. It’s a neat way to explore massive databases of music and even offers music playlists, and streaming services with the option to purchase. Google also allows you to search audio content on its desktop version as well as on the Google app for mobile devices. These music searches can also be linked to the Google Play library.

Stories, News & Mentions about NUWAE

Nuwae’s Stories on HackerNoon