DEV Community: Lucatonny Raudales

Obscura: la nueva y oscura variante de ransomware que pone en jaque a las empresas

Lucatonny Raudales — Wed, 24 Sep 2025 17:01:18 +0000

Publicado originalmente en BleepingComputer

Traducción y adaptación profesional al español para la comunidad hispanohablante en ciberseguridad.

Overview

El 29 de agosto de 2025, la firma de ciberseguridad Huntress reportó la detección de un nuevo y desconocido ransomware bautizado como Obscura.

Lo inquietante no es solo que no existían referencias públicas previas a este malware, sino la forma en que se propagó: utilizando el NETLOGON folder de un controlador de dominio, lo que le permitió expandirse de manera automática en toda la red de la víctima.

El caso Obscura ilustra perfectamente cómo los atacantes siguen innovando en tácticas de camuflaje, persistencia y presión psicológica, elevando el riesgo para organizaciones que no cuentan con visibilidad total de su infraestructura.

Contexto del descubrimiento

Huntress observó que el binario malicioso se ejecutaba en múltiples hosts dentro de la red comprometida.

El despliegue de agentes de seguridad en la víctima era limitado, lo que restringió la capacidad de detección y respuesta del SOC. Esto impidió identificar el vector inicial de acceso.

Sin embargo, se confirmó que el ransomware se almacenó en el controlador de dominio bajo la ruta:

C:\WINDOWS\sysvol\sysvol[dominio].local\scripts\

En un intento de camuflaje, el ejecutable llevaba el mismo nombre que el dominio de la víctima.

El análisis posterior reveló que estaba escrito en Go, con un Go build ID incrustado y referencias a directorios locales de desarrollo, por ejemplo:

/run/media/veracrypt1/Backups/Obscura/Locker/windows/locker/
/run/media/veracrypt1/Locker Deps/go1.15.linux-amd64/go/src/os/exec

Propagación y persistencia

La clave de la propagación de Obscura estuvo en aprovechar el NETLOGON folder, que sincroniza controladores de dominio. Al introducir ahí el binario, este se replicó automáticamente en múltiples sistemas.

Para garantizar persistencia, los atacantes crearon tareas programadas, entre ellas:

SystemUpdate: encargada de ejecutar el binario desde el recurso compartido NETLOGON.
iJHcEkAG: diseñada para habilitar acceso remoto RDP mediante firewall con el comando:

cmd.exe /C netsh firewall set service type = remotedesktop mode = enable > \Windows\Temp\SJYfXB 2>&1

Asimismo, el ransomware ejecutaba de forma embebida la eliminación de copias de seguridad locales:

cmd.exe /c vssadmin delete shadows /all /quiet

Propagación y persistencia

Para garantizar persistencia, los atacantes crearon tareas programadas, entre ellas:

SystemUpdate: encargada de ejecutar el binario desde el recurso compartido NETLOGON.
iJHcEkAG: diseñada para habilitar acceso remoto RDP mediante firewall con el comando:

Análisis técnico

Lenguaje: Go
Estrategia de camuflaje: nombre idéntico al dominio víctima
Propagación: NETLOGON folder (replicación automática)
Persistencia: creación de tareas programadas
Acciones destructivas: eliminación de shadow copies
Indicadores de desarrollo: rutas incrustadas con Veracrypt1 y dependencias de Go

Hasta el momento, no se ha identificado un grupo conocido detrás de Obscura ni se han encontrado sitios de filtración (leak sites) asociados.

Nota de rescate (traducción íntegra)

Archivo: README_Obscura.txt

¡Buen día! Su empresa ha fallado en una simple prueba de penetración.

Su red ha sido completamente encriptada por nuestro software.

Nuestro virus de ransomware utiliza tecnología de criptografía avanzada que hará muy difícil recuperar su información.

Toda la información ha sido robada.

Hemos extraído todos los datos de su red, incluidos NAS: pasaportes de empleados, documentación interna, documentos financieros, etc.

Tiene unas 240 horas para responder.

De no hacerlo, toda la información será distribuida.

Si decide contactarnos, estaremos dispuestos a negociar un precio de rescate. Al pagar recibirá:

un informe de cómo nos infiltramos en su red

instrucciones y software para descifrar los archivos

nuestra asistencia en la recuperación

Ellos no lo ayudarán; son sus enemigos.

Agencias de recuperación, la policía y otros servicios NO LO AYUDARÁN. Ellos quieren su dinero, pero no saben negociar.

Impacto estratégico

La campaña de Obscura pone de manifiesto varias lecciones clave:

Los controladores de dominio son un blanco prioritario. Al comprometer NETLOGON, los atacantes logran una propagación rápida y amplia.
La visibilidad parcial cuesta caro. Un despliegue incompleto de agentes SOC redujo la capacidad de reacción.
La presión psicológica sigue siendo parte del negocio. El tono de la nota de rescate busca aislar a la víctima de cualquier apoyo externo.
La profesionalización del ransomware es evidente. Uso de Go, tareas programadas y técnicas clásicas combinadas en un solo ataque.

Reflexión final

El ransomware Obscura no es solo un nuevo nombre en la larga lista de amenazas: es un recordatorio de cómo la falta de monitoreo profundo y segmentación de red puede ser explotada por actores maliciosos para paralizar infraestructuras críticas.

Mientras no se conozca su origen o posibles vínculos con grupos de ransomware establecidos, la comunidad de ciberseguridad debe estar atenta a nuevas muestras y tácticas asociadas.

Este hallazgo subraya la importancia de implementar una defensa en profundidad, fortalecer la supervisión de controladores de dominio y no depender exclusivamente de un solo nivel de protección.

Fuente original

Artículo completo en inglés:

Obscura, an obscure new ransomware variant – BleepingComputer

Fundamentos de GO

Lucatonny Raudales — Fri, 11 Jul 2025 18:12:59 +0000

Eres nuevo en Golang?, tienes una entrevista y quieres repasar los fundamentos del lenguaje?, o simplemente quieres ver algo interesante mientras mirás Harry Potter?...

Bien, hace poco estuve repasando los fundamentos de Go porque, seamos sinceros, a veces se nos olvida hasta de comer con tanta información que manejamos día a día.
Repasemos algunos fundamentos de golang que vinieron a mi cabeza:

Interfaces y composición en Go.
Manejo de errores (errors.Wrap, fmt.Efforf, etc.).
Goroutines y canales (¿cuando usarlos?, ¿cuando no usarlos?).
Uso de context (context.WithTimeout, cancelación de requests).
Struct tags (json, bson, validación con go-playground/validator).
Testeo: testing, testify, mocks.

Voy a explicar cada uno de los items anteriores como si estuviéramos hablando en una llamada o en una salida al mcDonald, con ejemplos claros y al grano.

Interfaces y Composición

¿Qué carajos es una interfaz en GO?
Una interfaz es básicamente un contrato.
Te dice qué estructura, métodos o componentes debe tener un tipo, pero no te dice como hacer las cosas.

type Animal interface {
    Speak() string
}

Ahora, cualquier struct que tenga ese método, ya cumple con los mandatos de la interfaz. No tenés que decir explícitamente implement Animal, Go lo deduce solo porque es muy inteligente, no como otros lenguajes que no quiero decir (Typescript, etc).

type Dog struct{}

func (d Dog) Speak() string {
    return "Guau!"
}

uso

func makeItSpeak(a Animal) {
    fmt.Println(a.Speak())
}

¿Y composición?
Go no tiene herencia como en otros lenguajes (gracias a Dios), pero podés componer structs. En español sería como meter un struct dentro de otro (como structs anidados)

type Kitchen struct {
    Color string
    Windows int
}

type Home struct {
    Kitchen // composición
    Rooms  int
}

uso

func main() {
    h := Home{Kitchen{"blue", 1}, 3}
    fmt.Println(h.Kitchen.Color) // "blue"
    fmt.Println(h.Kitchen.Windows) // 1
    fmt.Println(h.Rooms) // 3
}

⚠️ Manejo de errores (Como gente seria)

Go no tiene try/catch, acá se devuelve el error en cada acción(o en casi todas) y vos hacés con el error lo que tú quieras.

func dividir(a, b int) (int, error) {
    if b == 0 {
        return 0, fmt.Errorf("no se puede dividir por cero")
    }
    return a / b, nil
}

res, err := dividir(10, 0)
if err != nil {
    fmt.Println("Ups:", err)
}

¿Y si quiero más contexto?
Para eso está errors.Wrap de la librería pkg/errors, para decir no solo lo que pasó, sino también dónde ocurrió.

import "github.com/pkg/errors"

func readFile(path string) error {
    _, err := os.ReadFile(path)
    if err != nil {
        return errors.Wrap(err, "falló al leer el archivo")
    }
    return nil
}

realmente hay otras librerías que nos ayudan con esto y más, y de maneras distintas, pero para gusto los colores.

🚀 Goroutines y canales (concurrency sin drama)

¿Qué es una goroutine?
En Go, si querés que algo corra en paralelo mientras sigue ejecutándose el resto del programa, usás una goroutine.
Es como lanzar una función en segundo plano, pero mucho más liviano que un thread traidicional. Se lanza con la palabra reservada go.

func saludar(nombre string) {
    fmt.Println("Hola", nombre)
}

func main() {
    go saludar("Lucatonny") // esto se ejecuta en segundo plano
    fmt.Println("Programa principal sigue...")
    time.Sleep(1 * time.Second) // damos tiempo a que saludar termine
}

Si no ponés el Sleep, puede que la goroutine ni se alcance a ejecutar ya que el programa puede terminarse antes.

¿Y los canales?
Un canal (chan) sirve para que dos goroutines se pasen datos de forma segura. es como comunicarse entre multiversos así como el doctor Strange.

func enviar(ch chan string) {
    ch <- "Hola desde la goroutine"
}

func main() {
    ch := make(chan string)
    go enviar(ch)
    msg := <-ch
    fmt.Println(msg)
}

ch <- "Hola": envía al canal.
mensage := <-ch: recibe del canal.

Con esto evitás tener que usar locks o variables compartidas.

Ejemplo real: múltiples workers

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Printf("Worker %d procesando trabajo %d\n", id, j)
        time.Sleep(time.Second)
        results <- j * 2
    }
}

func main() {
    jobs := make(chan int, 5)
    results := make(chan int, 5)

    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    for j := 1; j <= 5; j++ {
        jobs <- j
    }
    close(jobs)

    for r := 1; r <= 5; r++ {
        fmt.Println("Resultado:", <-results)
    }
}

y ¿Cuando no usarlas?

Si necesitás un resultado inmediato (no paralelo).
Si no estás seguro de como coordinarlas (puede haber deadlocks).
Si vas a lanzar cientos sin control -> consumo de memoria innecesario.
si no hay un plan para cerrarlas (se pueden quedar vivas para siempre y consumir recursos innecesariamente hasta que explotes).

⏳ Uso de context (controlá tus procesos)

context es tu mejor amigo cuando hacés operaciones que podrían tardar mucho (como llamadas a APIs, DB, procesamiento pesado, etc.)

Te permite:

Cancelar procesos si se extienden del tiempo.
Cancelar cuando el usuario se va.
Encadenar procesos con timeout.

func hacerAlgo(ctx context.Context) {
    select {
    case <-time.After(3 * time.Second):
        fmt.Println("Proceso completado")
    case <-ctx.Done():
        fmt.Println("Cancelado:", ctx.Err())
    }
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
    defer cancel()

    hacerAlgo(ctx)
}

En este caso, el proceso se cancela a los 2 segundos.

Context también se usa así:

req, _ := http.NewRequestWithContext(ctx, "GET", "https://api.com", nil)

En servicios HTTP o gRPC, usar context es esencial para evitar que las goroutines queden abiertas esperando una respuesta que ya no importa.

Struct tags (los metadatos mágicos)
Los struct tagsson anotaciones que van junto al campo de un struct. Le dicen a Go (y a otras librerías): "Ey, tratá este campo así"

type Usuario struct {
    Nombre string `json:"nombre"`
    Edad   int    `json:"edad"`
}

u := Usuario{"Lucatonny", 300}
jsonData, _ := json.Marshal(u)
fmt.Println(string(jsonData)) // {"nombre":"Lucatonny","edad":300}

Si no ponés el tag, json.Marshal usaría Nombre y Edad, respetando las mayúsculas.

Validaciones con go-playground/validator
Es un paquete que nos ayuda a validar los valores de entrada y salida en cada campo que hemos definido en nuestro estruct.

type Registro struct {
    Email string `validate:"required,email"`
    Edad  int    `validate:"gte=18"`
}

validate := validator.New()
err := validate.Struct(Registro{})
if err != nil {
    fmt.Println("Error de validación:", err)
}

Te ahorra mucho código repetitivo para validar formularios, APIs, etc.

Testing (como pro y sin miedo)
Test básico

func Sumar(a, b int) int {
    return a + b
}

// archivo: sumar_test.go
func TestSumar(t *testing.T) {
    resultado := Sumar(2, 3)
    if resultado != 5 {
        t.Errorf("esperaba 5, obtuve %d", resultado)
    }
}

Con testify todo es más fluido

import (
    "testing"
    "github.com/stretchr/testify/assert"
)

func TestSumar(t *testing.T) {
    assert.Equal(t, 5, Sumar(2, 3))
}

¿Y si quiero mocks?
Supongamos que tenés la siguiente interfaz:

type EmailSender interface {
    Send(email string, content string) error
}

Podés crear un mock con testify/mock:

type MockSender struct {
    mock.Mock
}

func (m *MockSender) Send(email string, content string) error {
    args := m.Called(email, content)
    return args.Error(0)
}

y en el test tener:

func TestEnviarCorreo(t *testing.T) {
    m := new(MockSender)
    m.On("Send", "test@example.com", "hola").Return(nil)

    // Llamás a la función que usa EmailSender
    err := m.Send("test@example.com", "hola")
    assert.NoError(t, err)
    m.AssertExpectations(t)
}

Los mocks te permiten probar sin depender de servicios externos. Ideal en integración.

En Resumen
Go tiene esa belleza de ser simple, pero no simplista. Con estos fundamentos ya podés hacer APIs, workers, microservicios, CLI tools, y lo que se te ocurra. Lo importante no es solo saber qué hacen estas herramientas, sino cuándo usarlas y por qué.

Si algo de esto te sirvió, te aclaró o incluso te hizo decir “¡ahhh ahora entiendo!”, entonces ya valió la pena.

¿Querés ver más artículos como este? ¿Querés que arme una segunda parte con patrones, middlewares, caché, gRPC o integración con bases de datos?
Dejame un comentario o escribime por X (Twitter).

Y si recién estás empezando en Go: no te frustres si al principio parece raro. Todos pasamos por eso. Solo seguí escribiendo código, y un día te vas a dar cuenta de que ya pensás en Go.

Saludos y hasta pronto.
Lucatonny R. Raudales

From Software to Web3 to CyberSecurity

Lucatonny Raudales — Tue, 04 Mar 2025 04:22:01 +0000

Throughout my IT career, I’ve had the opportunity to work with companies of all sizes, from startups to large corporations. That’s one of the greatest advantages of remote work: access to a variety of projects and challenges that have helped me grow continuously.

In these 7 years of experience, I’ve gone through many phases—developing a simple landing page with WordPress, building smart contracts in Web3, and deploying cloud infrastructures capable of supporting over 4 million registered users (with around 800k concurrent users at peak times).

I never thought I’d end up dedicating myself to cybersecurity (although it was always one of those IT fantasies in the back of my mind).

Exploring as Many Areas as Possible
Over the years, my goal has always been to experiment with as many areas as possible (except for those that require 100% on-site work). I did this with a clear purpose: to discover what I truly love and what I want to dedicate my life to.

Now, do I know for sure what I want?

The truth is, I’ve never had an absolute answer, but I do know what I enjoy the most: Cloud.

Why Cloud Has Been My Greatest Passion
Cloud is the area I’ve enjoyed the most during these years. It’s where I’ve evolved the fastest and where my growth has felt exponential.

I was lucky enough to work on high-impact projects in small teams where every decision mattered, where the pressure was high, and where infrastructure needed to be scalable, resilient, and secure. This pushed me to give 110%, to read, to document myself constantly, and to acquire critical skills to support massive amounts of users and traffic.
**
But… why cybersecurity then?**

The Decision to Dive Into DevSecOps
The growing demand for security in the IT world is astonishing. The need to protect infrastructures, data, and applications is stronger than ever, and Cloud and Security must go hand in hand.

No, it’s not just about money. (Well… maybe a little. But that’s not the main reason).

The real reason is that DevSecOps is the missing piece that complements my career and life purpose. Since I love Cloud and enjoy DevOps, integrating security into this path is both a logical and exciting decision.

Learning and Excited to Enter the Cybersecurity Market
Right now, I’m pursuing a master’s degree in cybersecurity, which has allowed me to learn a lot about this field. Every day, I discover something new, and honestly, I’m super excited to step into the market and apply all this knowledge.

If you have any ideas, advice, or resources that can help me learn more and improve, I’d love to hear them! I’m on a journey of continuous growth, and any recommendations are welcome.

My passions for software development and Web3 remain strong, but I now see them as tools and knowledge that enrich my path toward cybersecurity. Plus, continuous learning has always been part of my DNA, and in this field, you never stop learning.

So yes, every day, I’m more convinced: DevSecOps is my path.

In this blog I will be telling you about my progress, but above all things that will be super interesting and from which we can learn a lot.

Cheers,
Lucatonny Raudales

X/Twitter
Github

De Software a Web3 a CiberSeguridad?

Lucatonny Raudales — Tue, 04 Mar 2025 04:18:35 +0000

A lo largo de mi vida profesional en IT, he tenido la oportunidad de trabajar en empresas de todos los tamaños, desde startups hasta grandes corporaciones. Esa es una de las grandes ventajas del trabajo remoto: el acceso a una diversidad de proyectos y retos que me han permitido crecer constantemente.

En estos 7 años de experiencia, he pasado por muchas etapas: desde desarrollar una simple landing page con WordPress hasta construir smart contracts en Web3 y desplegar infraestructuras cloud capaces de soportar más de 4 millones de usuarios registrados (y alrededor de 800k concurrentes en su pico más alto).

Nunca pensé que terminaría dedicándome a la ciberseguridad (aunque siempre fue una de esas fantasías IT que rondaban en mi cabeza).

Explorando todas las áreas posibles
Durante estos años, mi meta siempre ha sido experimentar en la mayor cantidad de áreas posibles (con excepción de aquellas que requieren trabajo 100% presencial). Lo hice con un propósito claro: descubrir qué es lo que realmente me apasiona y a qué quiero dedicarme el resto de mi vida.

Ahora bien, ¿ya sé con certeza qué quiero?

La verdad es que nunca he tenido una respuesta absoluta, pero sí tengo claro qué es lo que más me gusta: Cloud.

Por qué Cloud ha sido mi mayor pasión
Cloud es el área que más he disfrutado en estos años. Ha sido donde he evolucionado más rápido y donde he sentido que mi crecimiento ha sido exponencial.

Tuve la suerte de trabajar en proyectos de alto impacto, en equipos pequeños donde cada decisión contaba, donde la presión era alta y donde la infraestructura debía ser escalable, resiliente y segura. Esto me obligó a rendir al 110%, a leer, a documentarme constantemente y a adquirir habilidades críticas para soportar enormes cantidades de usuarios y tráfico.

Pero… entonces, ¿por qué ciberseguridad?

La decisión de sumergirme en DevSecOps
La creciente demanda por seguridad en el mundo IT es impresionante. La necesidad de proteger infraestructuras, datos y aplicaciones es más fuerte que nunca, y Cloud y Seguridad son dos mundos que deben ir de la mano.

No, no es solo por dinero. (Bueno… sí, un poco. Pero no es lo principal).

El verdadero motivo es que DevSecOps es la pieza que complementa mi carrera y mi propósito de vida. Como me encanta Cloud y disfruto el mundo DevOps, integrar la seguridad en este camino es una decisión lógica y emocionante.

Aprendiendo y emocionado por entrar en el mercado de ciberseguridad
Actualmente estoy cursando una maestría en ciberseguridad, lo que me ha permitido aprender muchísimo sobre este mundo. Cada día descubro cosas nuevas, y la verdad, estoy muy emocionado por salir al mercado y poner en práctica todo este conocimiento.

Además, si tienes ideas, consejos o recursos que me puedan ayudar a aprender más y mejor, ¡me encantaría escucharlos! Estoy en un camino de crecimiento constante y cualquier recomendación es bienvenida.

Mis pasiones por el desarrollo de software y Web3 siguen intactas, pero ahora las veo como herramientas y conocimientos que enriquecen mi camino hacia la ciberseguridad. Además, el aprendizaje continuo siempre ha sido parte de mi ADN, y en este campo, nunca se deja de aprender.

Así que sí, cada día me convenzo más: DevSecOps es mi camino.

En este blog te estaré contando sobre mis avances, pero sobre todo cosas de las cuales serán super interesantes y de las cuales podemos aprender mucho.

Saludos,
Lucatonny Raudales

X/Twitter
Github

Nuevo año y Nueva Startup

Lucatonny Raudales — Thu, 10 Oct 2024 04:34:49 +0000

El año 2024 comenzó con un gran reto; no tenía trabajo y muy pocos ahorros en mi banco (¡0 USD en mi cuenta y -700 USD en mi tarjeta de crédito!). Pero no hay mal que por bien no venga, y es que a mediados de enero, el 15 para ser precisos, comencé una nueva aventura en una empresa de Estados Unidos donde trabajan muchos developers de Latam.

Nuevo año, nueva startup
Esta es mi tercera experiencia en el mundo del emprendimiento. Mis dos startups anteriores —una de delivery y otra de crypto wallet— me enseñaron valiosas lecciones sobre innovación, adaptabilidad y la importancia de entender las necesidades del usuario. Cada desafío me ha preparado para enfrentar esta nueva aventura en el ámbito de la agrotech, un sector que me apasiona y que tiene un potencial inmenso para transformar la agricultura y la producción de alimentos.

En mi nuevo rol, estoy rodeado de un equipo talentoso y diverso(solo yo, pero con la fé de integrar gente maravillosa), lo que ha sido fundamental para alimentar mi creatividad y motivación. La combinación de conocimientos técnicos y experiencia en el campo agrícola nos permite abordar problemas complejos y desarrollar soluciones que no solo son innovadoras, sino también sostenibles.

¿Por qué agrotech?
La agricultura enfrenta múltiples desafíos: cambio climático, escasez de recursos, y la necesidad de aumentar la producción para alimentar a una población en crecimiento. En este contexto, la tecnología se presenta como una herramienta clave para optimizar procesos, mejorar la eficiencia y reducir el impacto ambiental. Estoy emocionado por contribuir a un sector que no solo busca rentabilidad, sino que también se preocupa por el bienestar del planeta y sus habitantes.

Mirando hacia el futuro
Mientras me sumerjo en esta nueva aventura, me encuentro reflexionando sobre los desafíos y oportunidades que se presentan. Estoy convencido de que, con la mentalidad adecuada y un enfoque centrado en el usuario, podemos crear soluciones que marcarán la diferencia. Cada línea de código, cada reunión y cada brainstorming nos acercan más a un futuro donde la tecnología y la agricultura coexisten en armonía.

Si bien el camino por delante no será fácil, estoy preparado para enfrentar cada obstáculo con la experiencia adquirida en mis startups anteriores. Estoy ansioso por compartir más sobre nuestro progreso y las innovaciones que estamos desarrollando en el espacio de agrotech. ¡Este es solo el comienzo de una emocionante travesía!

Lucatonny Raudales

X/Twitter
Github

La Belleza de SET en Typescript

Lucatonny Raudales — Tue, 27 Aug 2024 03:06:33 +0000

En mi último proyecto, he estado trabajando con la estructura de datos Set en TypeScript, y ha sido increíblemente útil para manejar colecciones de valores únicos. En este post, te explicaré cómo usar Set para gestionar arrays y cómo puede ayudarte a mantener tu código limpio y eficiente.

¿Qué es Set?
El objeto Set en JavaScript y TypeScript es una colección de valores donde cada valor debe ser único. Esto significa que no se permiten duplicados dentro de un Set. Es perfecto para situaciones en las que necesitas asegurar la unicidad de los elementos.

Creación de un Set
Puedes crear un Set usando new Set(). Puedes inicializarlo con un array u otro iterable.

const miSet = new Set([1, 2, 3, 4]);
console.log(miSet); // Output: Set { 1, 2, 3, 4 }

Agregar Elementos
Usa el método .add() para agregar nuevos elementos. Si el elemento ya existe, no se añadirá de nuevo.

miSet.add(5);
console.log(miSet); // Output: Set { 1, 2, 3, 4, 5 }

miSet.add(3); // No se añade de nuevo
console.log(miSet); // Output: Set { 1, 2, 3, 4, 5 }

Verificar Existencia
El método .has() te permite verificar si un Set contiene un elemento específico.

console.log(miSet.has(3)); // Output: true
console.log(miSet.has(6)); // Output: false

Eliminar Elementos
Para eliminar un elemento, usa el método .delete().

miSet.delete(4);
console.log(miSet); // Output: Set { 1, 2, 3, 5 }

Iterar Sobre un Set
Puedes iterar sobre los elementos de un Set usando forEach o un bucle for...of.

miSet.forEach(valor => {
  console.log(valor); // Output: 1, 2, 3, 5
});

for (const valor of miSet) {
  console.log(valor); // Output: 1, 2, 3, 5
}

Convertir un Set en un Array
Para trabajar con un Set como un array, usa el operador de propagación (...) o Array.from().

const arrayDesdeSet = [...miSet];
console.log(arrayDesdeSet); // Output: [1, 2, 3, 5]

const otroArrayDesdeSet = Array.from(miSet);
console.log(otroArrayDesdeSet); // Output: [1, 2, 3, 5]

Tamaño del Set
El tamaño de un Set se puede obtener con la propiedad .size.

console.log(miSet.size); // Output: 4

Conclusión
El objeto Set es una herramienta poderosa para gestionar colecciones de valores únicos en TypeScript. Me ha ayudado a mantener mis datos limpios y evitar duplicados en mi último proyecto. Si necesitas trabajar con listas de elementos únicos, definitivamente te recomiendo que explores Set.

Lucatonny Raudales
Saludos

GO: Concurrencia vs Paralelismo Para Tontos.

Lucatonny Raudales — Fri, 23 Aug 2024 02:33:20 +0000

Bienvenido a este post con un título un poco denigrante.
Pero, en este post quiero explicarte que son estas 2 características de la programación de una forma muy sencilla, en esta ocasión usando mi lenguaje de programación favorito GOLANG.

Imaginemos una cocina:

Cocinar un plato: Esto representa una tarea.
Un cocinero: Es un procesador.
Concurrencia:

Varios cocineros en la cocina: Cada uno preparando un plato diferente.
En Go: Cada cocinero sería una goroutine. Aunque la cocina (el procesador) solo tiene un horno, los cocineros pueden trabajar en sus platos de forma simultánea, pasando el tiempo en otras tareas mientras esperan que el horno esté disponible.
Paralelismo:

Varios hornos: Cada cocinero tiene su propio horno.
En Go: Si tenemos múltiples procesadores físicos, cada goroutine podría ejecutarse en un procesador diferente, cocinando varios platos al mismo tiempo de manera real.

¿Cuál es la diferencia?

Concurrencia: Las tareas se ejecutan de forma entrelazada, dando la ilusión de paralelismo, incluso en un solo procesador.
Paralelismo: Las tareas se ejecutan simultáneamente en múltiples procesadores, lo que acelera significativamente el proceso.

¿Cómo usarlos en Go?

Goroutines: Son como hilos ligeros. Para crear una goroutine, simplemente utilizamos la palabra clave go antes de una función:

Veamos un ejemplo sobre como podemos usar goroutines en golang:

go func() {
    // Código que se ejecutará en una goroutine
}()

Canales: Son tuberías por las cuales las goroutines pueden comunicarse y sincronizarse.
Imagina que son tubos para pasar ingredientes entre los cocineros

ch := make(chan int)
go func() {
    ch <- 42 // Enviar un valor por el canal
}()
value := <-ch // Recibir un valor del canal

Ejemplo práctico:

package main

import (
    "fmt"
    "time"
)

func worker(id int, c chan int) {
    for n := range c {
        fmt.Printf("Worker %d received %d\n", id, n)
        time.Sleep(time.Second)
    }
}

func main() {
    c := make(chan int)

    for i := 1; i <= 5; i++ {
        go worker(i, c)
    }

    for n := 1; n <= 10; n++ {
        c <- n
    }
    close(c)

    time.Sleep(time.Second)
}

La salida de este código sería

Worker 1 received 1
Worker 2 received 2
Worker 3 received 3
Worker 4 received 4
Worker 5 received 5
Worker 1 received 6
Worker 2 received 7
Worker 3 received 8
Worker 4 received 9
Worker 5 received 10

aunque aveces podría verse así

Worker 5 received 1
Worker 1 received 3
Worker 2 received 2
Worker 4 received 5
Worker 3 received 4
Worker 3 received 6
Worker 5 received 10
Worker 2 received 8
Worker 4 received 7
Worker 1 received 9

o así

Worker 5 received 1
Worker 1 received 2
Worker 2 received 3
Worker 3 received 4
Worker 4 received 5
Worker 1 received 6
Worker 2 received 7
Worker 3 received 8
Worker 5 received 9
Worker 4 received 10

¿Por qué la salida cambia cada vez que ejecuto el programa?

La razón principal por la que la salida del programa cambia en cada ejecución es debido a la naturaleza no determinista de la concurrencia.

Aquí hay un desglose de lo que está sucediendo:

Crear un canal: make(chan int) crea un canal de enteros. Este canal se utilizará para la comunicación entre las goroutines.

Iniciar goroutines: El bucle for i := 1; i <= 5; i++ { go worker(i, c) } inicia cinco goroutines, cada una con un ID único.
La función worker recibe el ID y el canal.

Enviar valores al canal: El bucle for n := 1; n <= 10; n++ { c <- n } envía los valores del 1 al 10 al canal.

Cerrar el canal: La llamada close(c) cierra el canal, indicando que no se enviarán más valores.

Recibir valores del canal: Cada goroutine recibe valores del canal usando el bucle for n := range c. Cuando se recibe un valor, se imprime en la consola.

Esperar a que las goroutines terminen: La llamada time.Sleep(time.Second) asegura que la goroutine principal espere a que las otras goroutines terminen antes de salir.

Hasta ahora:

Creamos 5 goroutines (cocineros) que reciben números por un canal.
Enviamos números al canal para que los cocineros los procesen.
Los cocineros trabajan de forma concurrente, procesando los números a medida que los reciben.

¿Por qué usar concurrencia y paralelismo en Go?

Mejor rendimiento: Especialmente en tareas I/O-bound (como leer archivos o hacer solicitudes HTTP).
Mayor capacidad de respuesta: La aplicación puede seguir respondiendo a otras solicitudes mientras una tarea está bloqueada.
Arquitecturas más escalables: Puedes distribuir el trabajo en múltiples núcleos o máquinas.

¡Recuerda!

La concurrencia y el paralelismo son herramientas poderosas, pero también pueden hacer que el código sea más complejo de entender y depurar. Es importante usarlas con cuidado y comprender sus implicaciones.

¿Quieres profundizar más en algún tema específico?

Podemos explorar conceptos como:

Sincronización: Mutexes, grupos de trabajo, etc.
Patrones de concurrencia: Producer-consumer, pipeline, etc.
Testing concurrente: Cómo probar código concurrente de manera efectiva.

Saludos,
Lucatonny Raudales

X/Twitter
Github

Forward Proxy & Reverse Proxy. Que es?

Lucatonny Raudales — Tue, 13 Aug 2024 03:24:40 +0000

Hola a todos,

Hoy vamos a tener una breve explicación sobre dos tipos de proxies que a menudo se confunden: el Forward Proxy y el Reverse Proxy. Ambos son herramientas valiosas en la administración de redes y la seguridad, pero cumplen funciones muy diferentes.

Primeramente definamos
Que es un Proxy?
~ Es un intermediario (puerta de enlace) que nos permite comunicarnos desde un dispositivo hacia otro dispositivo Teléfono > Servidor, Servidor > Teléfono, Computador > Computador, etc. para consultar y consumir datos como ser: música, video, información o simplemente una página web como la que estás viendo a través de una red.

Sabiendo que es un Server Proxy en simples palabras, ahora vamos a por lo que venimos.

Que es un Forward Proxy?

Un Forward Proxy es un intermediario entre los clientes (tú) y servidores externos como ser facebook o dev.to; no es nada más que eso. Actúa como intermediario entre tú, como cliente, y los servidores externos a los que deseas acceder. Eres tú, como cliente, quien configura el uso de un forward proxy para acceder a recursos externos desde tu red local. El proxy envía las solicitudes a los servidores externos en tu nombre.

Algunos de los propósitos más comunes son:

Anonimato: Oculta tú dirección IP como cliente .
Control de Contenido: Permite a las organizaciones filtrar y controlar el contenido que los usuarios pueden acceder.
Acceso a Contenidos Restringidos: Te ayuda como usuario a acceder a contenido que puede estar bloqueado en tu región.

Ejemplo de Uso: Tu, siendo un usuario en China deseas acceder a un contenido específico que está restringido en tu país. Con un forward proxy, puedes redirigir tu solicitud a través de un servidor en otra ubicación para eludir la restricción o, si la organización lo decide, el proxy puede bloquear tu solicitud por completo.

Reverse Proxy

Por otro lado, el Reverse Proxy actúa como intermediario entre los servidores a los que quieres acceder y tú. En este caso, tu estarás interactuando con el reverse proxy configurado en el servidor en lugar de interactuar directamente con el servidor al que quieres acceder. El reverse proxy se encarga de redirigir las solicitudes a los servidores backend adecuados.

Propósitos Comunes:

Balanceo de Carga: Distribuye el tráfico entre múltiples servidores para mejorar la disponibilidad y el rendimiento.
Seguridad: Puede ocultar la estructura interna de la red y proteger los servidores backend de accesos directos.
Caché: Almacena contenido en caché para mejorar la velocidad de acceso a recursos comunes.

Ejemplo de Uso: tú, como usuario solicitas acceso a un sitio web; la solicitud se envía al reverse proxy, que decide a qué servidor backend debe reenviar la solicitud y luego te devuelve la respuesta con lo que pediste.

Resumen
Forward Proxy: Intermediario para los clientes que acceden a recursos externos.
Reverse Proxy: Intermediario para los servidores que manejan las solicitudes de los clientes.

Espero que esta explicación te ayude a clarificar las diferencias entre forward proxies y reverse proxies. Si tienes preguntas o experiencias para compartir, ¡me encantaría leerlas!

Saludos,
Lucatonny Raudales

X/Twitter
Github

River: Tu Cola de Trabajos Go, Simple y Eficiente

Lucatonny Raudales — Fri, 09 Aug 2024 01:12:24 +0000

¿Qué es River?

River es una herramienta poderosa y fácil de usar diseñada para gestionar colas de trabajo en aplicaciones Go. Imagina que tienes una tarea que tarda mucho tiempo en completarse, como enviar correos electrónicos a miles de usuarios o procesar imágenes de gran tamaño. En lugar de bloquear tu aplicación principal, puedes enviar estas tareas a una cola y dejar que River se encargue de ejecutarlas en segundo plano.

¿Por qué usar River?

Simplicidad: River te permite crear y gestionar colas de trabajo con pocas líneas de código.
Fiabilidad: Tus trabajos siempre se ejecutarán, incluso si tu aplicación se reinicia.
Escalabilidad: River puede manejar cargas de trabajo variables y crecer junto con tu aplicación.
Flexibilidad: Puedes personalizar el comportamiento de River para adaptarlo a tus necesidades específicas.

¿Qué puedes hacer con River?

Procesar tareas asíncronas
Enviar correos electrónicos
Procesar imágenes
Transcodificar video
Importación de datos
Y mucho más

Instalación y Uso

Instalación:
go get github.com/riverqueue/river
Crear una cola:

package main

import (
    "github.com/riverqueue/river"
)

func main() {
    queue := river.NewQueue("my-queue", "postgres://user:password@host:port/database")
}

Encolar un trabajo:

type MyJob struct {
    Data string
}

queue.Enqueue(&MyJob{Data: "Hello, world!"})

Ejecutar los trabajos:

queue.Run()

Conclusiones
River es una excelente opción para desarrolladores Go que buscan una solución simple y eficiente para gestionar colas de trabajo. Sus características y facilidad de uso lo convierten en una herramienta indispensable para cualquier proyecto que requiera procesamiento de tareas en segundo plano.

Lucatonny Raudales

X/Twitter
Github

go #river #queue #opensource