teleren/devto huggingface dataset:
CORS - Cross Origin Resource Sharing
Tags: networking, node, distributedsystems
Published: 2023-05-24 20:04:09

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/62n296g2hv1zmiu27et1.png)

Os **navegadores** (**browsers**) iniciam o CORS como solicitação extra de "comprovação" para determinar se eles têm permissão para executar solicitações de origem cruzada. Portanto, o **CORS**, que significa _Cross Origin Resource Sharing_ (Compartilhamento de recursos de origem cruzada), é um protocolo que permite que os servidores recebam solicitações de diferentes domínios e com ele podemos ficar tranquilos em relação a segurança aplicada a uma API.

> Os desenvolvedores geralmente fazem solicitações de API externas para buscar dados de servidores externos. Às vezes, esses servidores também podem ser de domínios diferentes.

O CORS funciona da seguinte forma: Uma API é um procedimento definido para dois programas se comunicarem. Isso significa que os recursos da API são consumidos por outros clientes e servidores.

**Exemplo em desenvolvimento 1**:
<div align="center"><a href="https://www.section.io/engineering-education/how-to-use-cors-in-nodejs-with-express/"><img src="https://www.section.io/engineering-education/how-to-use-cors-in-nodejs-with-express/same-origin.jpg" width="100%"></a></div>

> O _cliente_ e o _servidor_ têm a **mesma origem**. Neste exemplo, o acesso aos recursos será bem-sucedido. Você está tentando acessar recursos em seu servidor e o mesmo servidor trata da solicitação.

**Exemplo em desenvolvimento 2**:
<div align="center"><a href="https://www.section.io/engineering-education/how-to-use-cors-in-nodejs-with-express/"><img src="https://www.section.io/engineering-education/how-to-use-cors-in-nodejs-with-express/diffrent-origin.jpg" width="100%"></a></div>

> O _cliente_ e o _servidor_ têm **origem diferente** um do outro, ou seja, acessam recursos de um servidor diferente. Nesse caso, tentar fazer uma solicitação a um recurso no outro servidor falhará.
>
> Esta é uma preocupação de segurança para o navegador. O CORS entra em ação para desabilitar esse mecanismo e permitir o acesso a esses recursos. Então, o CORS vai adicionar um cabeçalho de resposta: `access-control-allow-origins` e especificar quais origens são permitidas, e assim, o CORS garante que estamos enviando os cabeçalhos corretos.

**Exemplo em produção**:
> 👉 Meu aplicativo em `rootlearn.com` fazendo uma solicitação `GET` para `rootlearn.com` é uma solicitação de mesma origem
> 
> 👉 Meu aplicativo no `rootlearn.com` fazendo uma solicitação `GET` para o `google.com` é uma solicitação de origem cruzada
>
> ❌ Mas essas solicitações de domínio cruzado são restritas pelo navegador
>
> ✅ Depois que os desenvolvedores configurarem o CORS no servidor para aceitar solicitações de outros domínios, o navegador iniciará uma verificação de comprovação

Então o CORS serve para verificar se o compartilhamento de recursos é permitido no servidor de destino e a solicitação de comprovação usa o método HTTP: `OPTIONS`.
Exagerando na cobertura de código? Aprenda agora e veja que menos, é mais!
Tags: testing, development, test
Published: 2023-05-24 19:55:36

---
title: Exagerando na cobertura de código? Aprenda agora e veja que menos, é mais!
published: true
description: Preocupação excessiva com a cobertura de código? Vamos nesse vídeo te explicar com o que de fato você deveria estar preocupado
tags: #testing #development #test
# cover_image: https://direct_url_to_image.jpg
# Use a ratio of 100:42 for best results.
# published_at: 2023-05-24 17:02 +0000
---

Fala Dev! Você ou seu time tem uma preocupação excessiva sobre a cobertura de código? Se sim, essa mensagem é especial para você e no vídeo de hoje vou tentar explicar os maleficios que isso pode trazer para o seu código.

Só clicar no link abaixo e aproveitar!

(https://www.youtube.com/watch?v=-Z9uM4HLzMk)
DevOps Project Part 1: 3-tier Web Application
Tags: devops, beginners, projects, aws
Published: 2023-05-24 19:48:55

As promised, the next posts will be about a DevOps project that covers various aspects. From setting up a website architecture manually to incorporating DevOps tools, and eventually exploring cloud containers and infrastructure as code. It's an exciting opportunity for me to gain practical experience in building resilient and scalable systems. I look forward to sharing my progress and insights with you as I continue this journey. 

---


#Overview
Our solution comprises several key components:

Infrastructure: AWS
Webserver: Red Hat Enterprise Linux 8
Database Server: Ubuntu 20.04 with MySQL
Storage Server: Red Hat Enterprise Linux 8 with NFS
Programming Language: PHP
Code Repository: GitHub


![3 tier Web architecture](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/lfv0ob3yivzacwy1yq34.png)


To visualize the architecture, we follow a common pattern where multiple stateless web servers share a centralized database, and they access shared files through the Network File System (NFS). This setup allows our web servers to seamlessly serve the same files, as if they were locally stored, providing efficient and reliable file access across the infrastructure.

---

Follow the steps provided on documentation to implement this architecture on AWS:

{% github luismanuu/DevOps-3TierWebApp %}

**Important**: Do not forget to STOP your EC2 instances after completion of the project to avoid extra costs. Also keep in mind instance DNS change after turning off.

---
##Lessons learned (In my case):

-Understanding basic of AWS networking (subnets, private ips, Security groups inbound/outbound)

- Creating partitions using **gdisk **utility.

- Managing physical, logical and group volumes with **pvcreate**, **vgcreate**, **lvcreate** utilities.

- Format logical volumes with **mkfs **utility.

- Mount logical volumes in NFS server with **mount **utility and make them persist by modifying **/etc/fstab**

- Mount in web server directory and target to NFS server’s using **mount** utility

- Installing and configuring a NFS server with **nfs-utils**


---

**Next steps**:
- Adding Load Balancer
- Implementing Jenkins as DevOps tool
How to know if a Pandas DataFrame was modified
Published: 2023-05-24 19:43:44

I would like to know if a `pandas.DataFrame` was modified or not.

One idea is to create a hash value for the whole data frame.

`# Credits: https://stackoverflow.com/a/62754084/4865723
hashlib.sha1(pd.util.hash_pandas_object(df).values).hexdigest() `

But I wonder if there might be another way doing this. Any ideas?
YugabyteDB Community Open Hours: Episode 1, In The Beginning...
Tags: distributed, sql, yugabytedb, postgres
Published: 2023-05-24 19:35:44

Do you have questions about Distributed SQL Databases, Open Source, PostgreSQL, YugabyteDB? 
Here is the first episode of our new weekly community hours:
{% embed https://www.youtube.com/embed/sfsroDMagFQ %}
100 Days Coding Challenge - Day 5: FreeCodeCamp Web Design
Tags: webdev, programming, css, 100daysofcode
Published: 2023-05-24 19:21:38

## Day 5

Hi guys!! I finish the four-certification project in freecodecamp :D it should have a video but for some reason the freecodecamp page don't show the video, anyways, I will up this to my GitHub and I will improve it.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/v73tuef9w6243gx1j4ss.png)


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/17vcpa3he9kcgspqnfeu.png)
Messaging Queues
Tags: distributedsystems, devops, microservices
Published: 2023-05-24 19:16:40

Em ciência da computação, uma **fila de mensagens** (MQ - Messaging Queue) é um componente de engenharia de software usado para a comunicação entre processos ou threads dum mesmo processo. O componente usa uma fila de mensagens.

Filas de mensagens provêm um protocolo de comunicação assíncrona, de forma que o remetente e o destinatário da mensagem não precisam interagir ao mesmo tempo. As mensagens são enfileiradas e armazenadas até que o destinatário as processe. A maioria das filas de mensagens definem limites ao tamanho dos dados que podem ser transmitidos numa única mensagem. Aquelas que não possuem tal limite são chamadas caixas de mensagens.

Faz sentido usar as filas de mensagens quando os interlocutores estão ligados através de redes de grande escala, em países diferentes, para as quais a probabilidade de desconexão não é desprezível.

## ZeroMQ (ØMQ)

## Apache ActiveMQ

## RabbitMQ

O **RabbitMQ** é um software de mensagens com código aberto, que implementou o protocolo "Advanced Message Queuing Protocol", que foi estendido com uma arquitetura de plug-in para suportar o protocolo "Streaming Text Oriented Messaging Protocol", o MQTT entre outros protocolos.
What are some obscure technologies you once learnt and don't expect to use them again?
Tags: discuss, programming, learning
Published: 2023-05-24 19:09:36

And what still **stuck with you** after that experience? What unique facts do you still remember?

I start!

At my first (actual) job, I used [Zope2](https://www.zope.dev/), a Python framework that, for that version, was able to hold code and templates in its database. The database was not relational, but instead, a tree-like structure of objects, called [ZODB](https://zodb.org/en/latest/) - zope object database. I see both projects are actively maintained.

In a big tech I had to migrate some API clients that were written in Perl, while some template rendering was done in [Mason](https://metacpan.org/pod/Mason). What stuck with me, was that Mason scripts had some kind of delimitation of execution context; they had some kind of header that was being executed in a faster manner than the rest of the script. Can't remember much.

In spring 2022, I went through Primeagen's [Solidity](https://soliditylang.org/) class on frontendmasters when I was doing "my research" on non-fungible tokens and blockchain tech. I don't see myself coming back to that language, but it did showcase a framework in which operations matter in terms of cost. Directly. In 2022 I also watched Richard Feldman's class on [Rust](https://www.rust-lang.org/) - the way you could "cast" the life span (*lifetime*) of the allocated memory for a variable to an annotation (*'a*) - that, that stuck with me. Probably, on this list, Rust has the highest potential to find its way into my keystrokes again.

Reminding myself of computational cost and memory brings me back memories of all the obscure development environments I went through in my 4-year Computer Science Bsc - [Assembly](https://en.wikipedia.org/wiki/Assembly_language) (mnemonic processor instructions), Matlab (actually [Octave](https://octave.org/), useful for running numerical algorithms that approximate or sample continuous signals), [Verilog](https://en.wikipedia.org/wiki/Verilog) (simulating simple logical circuits or more advanced electronics, using static gates as well as clock based circuits). Then we have the other programming paradigms that we experimented in, as students: [Prolog](https://www.swi-prolog.org/features.html) (solving the Wolf, Sheep And Cabbage Game), [Clips](https://www.clipsrules.net/) and [Haskell](https://www.haskell.org/) (functional programming).

Can you top it? :) What's your less-popular development experience?
API Gateway
Tags: microservices, devops, distributedsystems, node
Published: 2023-05-24 19:01:32

<img src="https://user-images.githubusercontent.com/61624336/225918759-79e0f659-d290-428c-bb23-e03bdd8cf0a1.gif">

Um **API Gateway** (AG) é um servidor/padrão arquitetural para sistemas distribuídos que consiste e atua como um único ponto de entrada para as chamadas de API de um conjunto de **microsserviços**. Ele é responsável por receber as solicitações do cliente, as encaminha para o serviço ou microsserviço apropriado e, em seguida, retornar as respostas do servidor ao cliente (modelo cliente-servidor). Algumas das principais funcionalidades comuns de um AG são: roteamento, balanceamento de carga, autenticação, autorização e transformação dos dados. 

O AG é responsável por tarefas como roteamento, autenticação e limitação de taxa. Isso permite que os microsserviços se concentrem em suas tarefas individuais e melhorem o desempenho geral e a escalabilidade do sistema.

Aqui estão os principais usos do AG:

- 𝗥𝗼𝘂𝘁𝗶𝗻𝗴: O AG recebe solicitações de clientes e as encaminha para o microsserviço apropriado. Isso permite que os clientes acessem os vários microsserviços por meio de um único ponto de entrada, simplificando o design geral do sistema.

- 𝗦𝗲𝗰𝘂𝗿𝗶𝘁𝘆: O AG pode ser usado para autenticar clientes e aplicar políticas de controle de acesso para os microsserviços. Isso ajuda a garantir que apenas clientes autorizados possam acessar os microsserviços e ajuda a evitar o acesso não autorizado.

- 𝐓𝐫𝐚𝐧𝐬𝐟𝐨𝐫𝐦𝗶𝗻𝗴 𝐫𝐞𝐪𝐮𝐞𝐬𝐭𝐬 𝐚𝐧𝐝 𝐫𝐞𝐬𝐩𝐨𝐧𝐬𝐞𝐬: AG pode transformar solicitações de entrada e respostas de saída para e para o back -end para atender às necessidades de diferentes clientes ou cumprir diferentes arquiteturas de back -end.

- 𝗥𝗮𝘁𝗲 𝗹𝗶𝗺𝗶𝘁𝗶𝗻𝗴: Você pode limitar o acesso do cliente a microsserviços com um AG. Isso pode ajudar a evitar ataques de negação de serviço e outros tipos de comportamento mal-intencionado.

- 𝗟𝗼𝗮𝗱 𝗯𝗮𝗹𝗮𝗻𝗰𝗶𝗻𝗴: O AG pode distribuir solicitações recebidas entre várias instâncias de um microsserviço, permitindo que o sistema lide com um número maior de solicitações e melhorando seu desempenho geral e escalabilidade.

- 𝗖𝗮𝗰𝗵𝗶𝗻𝗴: O AG pode armazenar em cache as respostas dos microsserviços, reduzindo o número de solicitações que precisam ser encaminhadas aos microsserviços e melhorando o desempenho geral do sistema.

- 𝗦𝗲𝗿𝘃𝗲𝗿𝗹𝗲𝘀𝘀 𝗲𝘅𝗲𝗰𝘂𝘁𝗶𝗼𝗻: AG pode se integrar a outros serviços, como AWS Lambda, para habilitar arquiteturas sem servidor e possibilitar o processamento complexo de solicitações sem a necessidade de um servidor dedicado.

- 𝗖𝗶𝗿𝗰𝘂𝗶𝘁 𝗯𝗿𝗲𝗮𝗸𝗲𝗿: AG pode ser usado para implementar padrões de disjuntores, o que pode ajudar a proteger contra falhas em cascata e melhorar a resiliência do seu sistema.

- 𝗥𝗲𝘃𝗲𝗿𝘀𝗲 𝗽𝗿𝗼𝘅𝘆: o AG pode atuar como um proxy reverso, roteando as solicitações recebidas para o serviço de back-end apropriado com base no caminho da solicitação ou em outros critérios.

- 𝗔𝗣𝗜 𝘃𝗲𝗿𝘀𝗶𝗼𝗻𝗶𝗻𝗴: AG pode ser usado para implementar versionamento de API, permitindo manter várias versões de uma API e gerenciar a transição de uma versão para outra.
Bigg Boss 17 All Latest Episodes
Published: 2023-05-24 18:50:59

The big boss season 16 recently went to the grand finale. MC stand was the winner of bigg boss season 16. The people want to know about the season 17 starting date. The season rolled on television screens for more than a few weeks. In this post, we are going to tell you about when bigg boss season 17 will start, Who will be the cast of Big Boss Season 17, Who will be the contestants, and what will be the prize money Of Bigg Boss Season 17. To know all about Bigg Boss Season 17 Starting Date stay with us in this post at last.

[url=https://biggboss17.cam/]Bigg Boss 17 All Latest Episodes[/url]
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/jopmg8gheln5pq8famux.jpg)
Effective Error Handling in JavaScript: Best Practices
Tags: webdev, javascript, beginners, programming
Published: 2023-05-24 18:44:32

Error handling is a crucial aspect of JavaScript development. Properly managing and handling errors in your code can greatly improve the stability, reliability, and user experience of your applications. In this blog post, we will explore best practices for effective error handling in JavaScript, enabling you to write cleaner code and handle errors gracefully.

**1.Use Try-Catch Blocks**
One of the fundamental techniques for error handling in JavaScript is using try-catch blocks. Wrap the code that might throw an error inside a try block, and catch the error in the catch block to handle it appropriately. This allows you to prevent crashes and handle exceptions in a controlled manner

```
try {
  // Code that may throw an error
} catch (error) {
  // Handle the error
}
```
**2.Provide Descriptive Error Messages**
When an error occurs, it's essential to provide clear and informative error messages. Avoid generic error messages that don't provide meaningful information to developers or users. Include relevant details such as the error type, location, and any contextual information that can help identify the cause of the error.

```
try {
  // Code that may throw an error
} catch (error) {
  console.error("An error occurred:", error.message);
}

```
**3.Handle Different Types of Errors**
JavaScript provides various types of built-in errors, such as TypeError, ReferenceError, and RangeError. It's important to handle different error types appropriately based on their specific characteristics. Understand the types of errors that can occur in your code and implement specific error handling logic for each type.

```
try {
  // Code that may throw an error
} catch (error) {
  if (error instanceof TypeError) {
    // Handle TypeError
  } else if (error instanceof ReferenceError) {
    // Handle ReferenceError
  } else {
    // Default error handling
  }
}

```
**4.Logging and Error Tracking**
Logging errors is essential for debugging and troubleshooting. Utilize console logging to capture errors during development, but be cautious not to expose sensitive information in production environments. Consider implementing error tracking tools like Sentry or Rollbar to track and monitor errors in your live applications.

**5.Graceful Degradation and User Feedback**
When errors occur in client-facing applications, it's crucial to provide users with meaningful feedback. Display user-friendly error messages or fallback UIs to gracefully handle errors without disrupting the user experience. Strive to ensure that users understand the issue and provide guidance on how to resolve it or seek support.

**6.Test and Refine Error Handling**
Thoroughly test your error handling code to ensure it functions as expected. Create test cases that cover different scenarios and error conditions. Continuously monitor and refine your error handling strategy based on user feedback, application analytics, and identified pain points.
Como usar FastAPI
Tags: español, fastapi, python
Published: 2023-05-24 18:27:41

Hola a todos!
En este articulo les voy a mostrar como usar la libreria de Python FastAPI.
Para empezar, quieres crear un `Virtual Environment` pa
a asegurar que todo funcione, puedes crearlo usando estos comandos:
```python
python3 -m venv myenv        # Crea un entorno virtual llamado "myenv"
source myenv/bin/activate  # Activa el entorno virtual
```

Despues, vas a querer installar la libreria de FastAPI, lo puedes hacer usando `PIP`:

```
pip install fastapi
```

Tambien vas a necesitar esta libreria:

```
pip install uvicorn
```

Ahora, puedes escribir este codigo en un archivo `main.py`:
```python
from fastapi import FastAPI, APIRouter

app = FastAPI()
router = APIRouter()
```

Ahora escribe este codigo:
```python
@router.get("/")
async def root():
    return {"message": "¡Hola, FastAPI!"}
```

Aqui, `@router.get("/")` es donde la api va ser llamada, por ejemplo si el URL es 217.734.1.237:80000, si entramos ahi nos va a devolver "message" : "¡Hola, FastAPI!", si cambias el `/` por ejemplo por: `/api/v1` tendras que ir a la URL: 217.734.1.237:80000/api/v1 para llamarla.

Ahora para correr el programa necesitas usar este commando:
```
uvicorn main:app --reload
```
Bueno, eso es de mi parte!
espero que le gusto :)
Implementing Azure Key Vault
Tags: azure, cloud, devops, cloudcomputing
Published: 2023-05-24 18:17:48

**What is a Key Vault**

Azure key vault enables you to securely store secrets such as tokens, passwords, certificates, cryptographic keys and API keys.

Azure key vault also provides a centralized, cloud-based service for creating, storing and managing keys and certificates. By storing secrets in key vault you gain the capability to easily monitor and audit access and also gain the capability to easily use these secrets among many Azure services.

In this guide we will be creating a key vault and then store a secret password within it.

**_Creating a Key Vault_**

**Step 1:**
Visit [portal.azure.com](url), login or sign up if you don't have an account, you can get a free account at [azure.microsoft.com/en-us/free/](url)

**Step 2:**
On the Azure portal page **click the search box** and **enter key vault**, then **click key vault**

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/upctl8k2in6iy9i0jnwa.png)

**Step 3:**
On the Key vault page **click create button**

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/9q1gkp364eroifpfm8my.png)

**Step 4:**
**Select a resource group** or **create a new one** by **clicking create new option** shown below the input bar, **enter a key vault name** of your choice, **choose a Region** of your choice and leave pricing tier as standard

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/lzczvrtrpufvhwijl0es.png)

**Step 5:**
**Leave days to retain deleted vaults at 90**, then **tick disable purge protection**, lastly **click review + create**

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ma37ziboc6x4jizwsgdh.png)

**Step 6:**
After validation has passed **click create button**

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/tjmkien9vomh49mbpd0r.png)

**Step 7:**
After deployment is completed **click go to resource**

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/hswdo5d26s67ta6zy1t2.png)

**_Storing a secret password in our Key Vault_**

**Step 1:**
On the key vault page **click secret** on the left hand side

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/nj1qw06lmydr8c3ee127.png)

**Step 2:**
When the secret page opens **click Generate/Import**

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/k5j7j3uckaz33t65m7pc.png)

**Step 3:**
**Leave upload options as default**, **enter a secret name** of your choice, **enter any secret value** of your choice you want to keep in Azure key vault, then **set activation date and set expiration date**, leave the rest the settings as default

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/7zzl83o7kmj060uwa1ty.png)

**Step 4:**
Viola!!! you have successfully added a secret to a key vault

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/tbvu48t5i4vsuj05zp57.png)