Tracking Docker container status in real time is a common challenge in DevOps. Popular tools like cAdvisor and the default Docker exporter for Prometheus often lack direct metrics for container states, meaning key insights—such as the number of containers that are running, stopped, or inactive—require complex workarounds. This limitation can complicate monitoring and lead to unreliable data.
Before creating docker_container_exporter, I relied on complex Prometheus queries to retrieve container statuses. This often involved calculations based on the last time a container was seen as active, but this approach had a major flaw: if the query time range didn’t match the last activity timestamp precisely, the data could be inaccurate or incomplete. Monitoring container states shouldn’t be this difficult.
With docker_container_exporter, this problem is solved. My tool captures real-time Docker container statuses, providing data on the number of running, stopped, and other container states, all in a Prometheus-compatible format. You can collect these metrics through a standard Prometheus polling process, or use agents like Grafana Alloy to push the data to Prometheus storage or compatible DB servers like Grafana Mimir or Thanos.
Tired of updating documentation across multiple platforms? If your projects rely on Notion for planning and GitHub for collaboration, you might find yourself constantly re-copying information from your repository to your Notion pages.
This handy command-line tool allows you to sync your Markdown files directly to Notion, saving time and keeping everything in one place.
Why Syncing Docs with Notion Matters
Many businesses, freelancers, and creators rely on Notion for organizing their workflows and GitHub for managing code and documentation. But each time your repository changes, your Notion page can easily fall out of date, creating a disconnect between your development work and your project documentation. readme2notionbridges this gap by automatically updating your Notion pages with the latest content from your repositories. You get an always-up-to-date Notion page that syncs with your codebase, so everyone on your team has the latest info in real time.
What is readme2notion?
At its core, readme2notion is a command-line tool that takes a Markdown file, converts it into Notion blocks, and uploads the content to a specified Notion page. This tool is versatile, finding the appropriate Notion page by name or creating one if it doesn’t exist. Once set up, it can transform your Markdown files into well-organized Notion pages with just one command.
How readme2notionWorks
Markdown Conversion: The tool reads your Markdown file and converts it into Notion-friendly blocks.
Upload and Sync: It then uploads the converted content to a Notion page, either updating an existing page or creating a new one based on the settings you choose.
Automated Updates: With a pre-push hook, readme2notion can automate the process, so every time you push a new change to your repository, your Notion page stays updated without any extra effort.
Key Features of readme2notion
Simple Conversion: Easily converts Markdown text into Notion’s block-based format.
Automatic Page Updates: Finds or creates the appropriate Notion page in the database you specify, meaning your docs are always up-to-date.
Pre-Push Hook: This feature allows for completely automated updates to Notion. With every push, your Notion page gets a fresh update, making it perfect for remote teams or anyone who needs a reliable source of truth for documentation.
Why You Should Try readme2notion
Updating Notion pages by hand can be tedious, especially if you’re a developer or creator juggling multiple projects. This tool eliminates the hassle by letting you write documentation once in your repository’s README file and automatically reflecting those changes in Notion. Plus, readme2notionworks seamlessly within your existing Git workflows, allowing your team to focus on what matters—building and creating—while staying informed and organized.
If your documentation process could use an upgrade, give readme2notiona try. It’s the easiest way to ensure your Notion workspace always reflects the latest state of your codebase.
Packaging Python applications into standalone executables can simplify deployment and distribution, especially when dealing with users who may not have Python installed or when aiming for a seamless installation experience. Three prominent tools in this space are PEX, PyOxidizer, and PyInstaller. In this post, we’ll explore each of these tools, highlighting their features, how they work, and their pros and cons to help you decide which one suits your needs.
PEX stands for Python EXecutable. It creates self-contained executable Python environments that are runnable on other machines without requiring a Python interpreter or additional dependencies.
Features
Self-contained Executables: Packages all dependencies into a single file.
Virtual Environment Management: Manages dependencies in an isolated environment.
Support for Multiple Python Versions: Can target different Python versions.
Reproducible Builds: Ensures consistent builds across different environments.
How It Works
PEX files are ZIP files with a special header that makes them executable. When you run a PEX file, it sets up an isolated environment and executes your application within it. Dependencies are resolved and bundled at build time, ensuring that the executable has everything it needs to run.
Pros and Cons
Pros:
Ease of Use: Straightforward command-line interface.
Isolation: Avoids conflicts with system-installed packages.
PyOxidizer is a tool that produces distributable binaries from Python applications. It embeds the Python interpreter and your application into a single executable file.
Features
Single Executable Output: Creates a single binary without external dependencies.
Embedded Python Interpreter: Bundles a Rust-based Python interpreter.
Cross-Compilation: Supports building executables for different platforms.
Performance Optimization: Optimizes startup time and reduces runtime overhead.
How It Works
PyOxidizer uses Rust to compile your Python application into a binary. It embeds the Python interpreter and compiles your Python code into bytecode, which is then included in the binary. This approach results in a single executable that can be distributed without requiring a separate Python installation.
Pros and Cons
Pros:
No Runtime Dependencies: Users don’t need Python installed.
Cross-Platform Support: Can build executables for Windows, macOS, and Linux.
Optimized Performance: Faster startup times compared to other tools.
Cons:
Complex Configuration: Requires understanding of Rust and PyOxidizer’s configuration.
Relatively New Tool: May have less community support and fewer resources.
PyInstaller bundles a Python application and all its dependencies into a single package, which can be a directory or a standalone executable.
Features
Multi-Platform Support: Works on Windows, macOS, and Linux.
Customizable Builds: Allows inclusion or exclusion of files and dependencies.
Support for Various Libraries: Handles complex dependencies like NumPy, PyQt, etc.
One-Folder and One-File Modes: Choose between a directory of files or a single executable.
How It Works
PyInstaller analyzes your Python script to discover every other module and library your script needs to run. It then collects copies of all those files—including the active Python interpreter—and packs them into a single executable or a folder.
Pros and Cons
Pros:
Ease of Use: Simple command-line usage.
Wide Compatibility: Supports many third-party packages.
Flexible Output Options: Choose between single-file or directory output.
Cons:
Executable Size: Can produce large files.
Hidden Imports: May miss some dependencies, requiring manual specification.
Comparison
Feature
PEX
PyOxidizer
PyInstaller
Single Executable
Yes (but requires Python)
Yes
Yes
No Python Required
No
Yes
Yes
Cross-Platform
Yes (build on target OS)
Yes (cross-compilation)
Yes (build on target OS)
Ease of Use
Moderate
Complex
Easy
Executable Size
Large
Smaller
Large
Configuration
Flexible
Requires Rust knowledge
Simple
Community Support
Active
Growing
Extensive
GitHub Activity
Actively maintained
Unmaintained
Actively maintained
Conclusion
Choosing the right tool depends on your specific needs and the assurance of ongoing support:
Use PEX if you need a self-contained environment for systems where Python is available. Its active maintenance ensures that you can rely on timely updates and community support.
Use PyOxidizer if you prefer a single executable without runtime dependencies and are comfortable with Rust. Its growing GitHub activity signifies a promising future and dedicated maintenance.
Use PyInstaller if you value simplicity and extensive community support. Its active maintenance status means you can expect regular updates and a wealth of community resources.
Managing environment variables for different environments, such as production and development, is crucial for deploying applications effectively. In this post, I’ll demonstrate how to use Docker Compose with .env files to easily switch between these environments, using the example of setting a DEBUG_LEVEL variable to control application logging.
To start, you’ll need different .env files for each environment:
1. .env (Common configuration)
ENVIRONMENT=prodUBUNTU_VERSION=24.04
This common .env file sets the default ENVIRONMENT to prod (production) and specifies the Ubuntu version. These variables are used across all environments.
2. .env.prod (Production-specific configuration)
DEBUG_LEVEL=ERROR
In the production environment, DEBUG_LEVEL is set to ERROR to minimize logging output and avoid exposing sensitive information.
3. .env.dev (Development-specific configuration)
DEBUG_LEVEL=DEBUG
In the development environment, DEBUG_LEVEL is set to DEBUG to provide detailed logs for troubleshooting and development purposes.
The compose.yaml file is set up to dynamically load the appropriate environment file based on the ENVIRONMENT variable, which can be set either in the shell or in the .env file:
This configuration uses the env_file directive to load the environment-specific file (.env.prod or .env.dev) based on the value of the ENVIRONMENT variable.
If the ENVIRONMENT variable is set in both the .env file and the shell, the value set in the shell will take precedence. This is useful for temporarily overriding the environment setting without modifying the .env file. For example:
Setting the ENVIRONMENT variable in the shell:
exportENVIRONMENT=dev
If you also have ENVIRONMENT=prod set in the .env file, the shell setting will overwrite it, and the development environment settings will be used:
By using .env files and setting the ENVIRONMENT variable in the shell, you have the flexibility to manage environment variables dynamically. This approach simplifies switching between environments and ensures consistent deployment settings, minimizing the risk of configuration errors and improving application reliability.
In this post, I’ll demonstrate how powerful and flexible the .env file can be when setting up a compose.yaml for Docker Compose. This approach allows for easy management of environment variables, making your Docker configurations more dynamic and manageable.
However, to make the variables defined in the .env file available within the Docker container, you need to add a couple of lines to your compose.yaml file:
After updating the compose.yaml file, run the docker compose up command again. This time, you’ll notice that the UBUNTU_VERSION environment variable is now included in the container’s environment:
This is incredibly convenient because maintaining the .env file allows you to easily manage environment variables across different services without modifying the compose.yaml file each time. This example clearly illustrates how powerful and useful it is to use .env files in Docker Compose configurations.
El 2023 comenzó con una sensación de renovación y optimismo. Tras un período marcado por la pandemia, este año se presentó como un lienzo en blanco, lleno de posibilidades y nuevas experiencias. Aunque el COVID-19 ya no domina nuestras vidas como antes, su impacto sigue siendo palpable en cómo vemos el mundo y en cómo nos relacionamos los unos con los otros. Este año ha sido un viaje de redescubrimiento, desde encuentros más íntimos y significativos hasta eventos más grandes y festivos. Hemos pasado de una realidad de restricciones y cautela a una de mayor libertad y celebración. Y, al igual que el año pasado, este 2023 ha estado lleno de momentos memorables, como la fiesta de fin de años en Agres, que han marcado un regreso a las tradiciones y alegrías que tanto extrañábamos. Compartiendo estos momentos con seres queridos, como Xavi y su familia, he redescubierto el valor de la conexión humana y la alegría de estar juntos.
Aprendizajes
En este 2023, he acumulado una serie de lecciones que, en mi opinión, resumen los aspectos más esenciales que la vida me ha enseñado este año. No me detendré a analizar la diferencia entre aprender e interiorizar, aunque es un tema fascinante. Sin embargo, quiero destacar que el proceso de aprender, y más aún el de re-aprender, es una constante en la vida. A menudo, nos encontramos con lecciones que necesitamos experimentar varias veces antes de que realmente se asienten en nuestra comprensión y comportamiento. A continuación, comparto las lecciones más significativas que he aprendido este año, las cuales han requerido tiempo y reflexión para integrarlas plenamente en mi vida.
He desarrollado una mayor conciencia de mis limitaciones personales en cuanto a la concentración y el tiempo necesario para absorber e interiorizar información clave. Al adentrarme en el mundo del trading, esta experiencia me ha obligado a ser aún más disciplinado con mi tiempo y energía, enseñándome a valorar cada momento y a utilizarlo sabiamente. A su vez, he comprendido que existe un delicado equilibrio entre el tiempo que se necesita para aprender y el tiempo para ejecutar. Esta comprensión ha sido crucial para planificar mejor mis proyectos y tareas, asegurándome de dedicar suficiente tiempo tanto a la fase de aprendizaje como a la acción necesaria para alcanzar mis objetivos.
Delegar Trabajo a los Estudiantes. He aprendido la importancia de dejar que los estudiantes trabajen de manera independiente. Me di cuenta de que, al soltar las riendas, ellos pueden sorprenderte con su capacidad de resolver problemas y su creatividad. Este enfoque no solo les beneficia a ellos en su aprendizaje, sino que también me ha permitido enfocarme en otros aspectos cruciales de mi labor educativa.
He tomado conciencia de la importancia de una alimentación saludable y el autocuidado, aunque aún estoy lejos de lograrlo plenamente. Este año, he aprendido profundamente que sin salud no hay nada; es nuestro bien más preciado. A pesar de no haber alcanzado aún mis objetivos en este aspecto, reconozco que el cuidado de la salud es fundamental y estoy comprometido a trabajar hacia un bienestar físico y mental más sólido.
Proyectos y marca personal
El único libro no técnico que he tenido la oportunidad de leer este año ha sido “Manifest per als herois de cada dia” de Robin Sharma. Como suele suceder con este autor, el libro me ha llevado a reflexionar y trabajar en aspectos personales profundos, recordándome la importancia de centrarse en lo que realmente importa en la vida. Todavía recuerdo esos días de verano en la playa disfrutando de la compañía de este gran libro.l
En el ámbito más cercano a lo profesional, quiero destacar “Industria 4.0, la transformación digital en la industria” de Jaume Martínez Aguiló. Tuve el placer de almorzar con él y recibir una dedicatoria en su libro. Leer a alguien con una perspectiva de diferente sobre temas que domino siempre es una oportunidad para replantear mi comprensión y, aunque en ocasiones no comparta completamente su visión, su libro ha sido una fuente valiosa de conocimiento. Muy interesante poder ver la Industria 4.0 des de la óptica de un director financiero.
Por otro lado, debido a la carga de trabajo hacia finales de año, he tenido que reducir mi actividad en redes sociales y en mi marca personal oriolrius.me. Simplemente, no he podido manejar el volumen de trabajo que tenía. Suerte de la ayuda de Fátima y la paciencia de mi familia.
Sin embargo, el proyecto que llevo adelante como hobby, de carácter más técnico y que me permite profundizar en temas de dudosa rentabilidad, sigue creciendo poco a poco. Me refiero a Industry 4.0 systems, un proyecto que me apasiona y en el que invierto mi tiempo libre.
Finalmente, este año ha estado marcado por una pérdida muy significativa. El adiós a Leonard Janer, una figura y mentor fundamental en mi vida. Fue una excelente persona, un profesor incomparable, un técnico apasionado y un amigo inigualable. Su partida ha dejado un vacío irremplazable, y siempre estaré agradecido por todo lo que me enseñó y compartió conmigo. GRACIAS POR TODO, LEONARD.
Familia y temas personales
El año ha estado marcado por un proyecto que nos ha mantenido muy ocupados: la reforma de la cocina y el comedor. Tomamos la decisión de unir ambos espacios, creando un único y acogedor lugar en nuestro hogar. Desde el primer día del año, nos hemos sumergido en un torbellino de planificación, diseño, selección de materiales, toma de decisiones, contrataciones y revisiones.
Ha sido un proceso intenso, lleno de detalles y decisiones importantes. Durante los meses de obras, nuestro refugio fue el apartamento en la playa. Aquí, las visitas a restaurantes se convirtieron en algo frecuente, tanto que terminamos haciéndonos socios del Club Marítimo de Cubelles. Esto no solo nos benefició con descuentos, sino que también abrió una nueva puerta para Roc, quien comenzó su aventura en el mundo de la vela.
Para seguir hablemos un poco de los viajes que hemos podido disfrutar este año.
En enero, nos aventuramos a Gran Canaria para visitar a la familia de Oriol y Gemma. Nos maravillamos con lugares inesperados en Canarias. Nunca imaginamos que había zonas húmedas y montañosas; como Teror y Artenara, donde Oriol tiene la base.
En Semana Santa, vivimos la magia de Eurodisney, una experiencia inolvidable llena de diversión y fantasía. Realmente fue un viaje que me sorprendió muy positivamente. Más allá de las atracciones, todo el montaje y la logística que supone un parque de atracciones como este es algo deslumbrante. Además, ver a toda la familia disfrutar el sueño de vivir momentos mágicos juntos, no tiene precio.
En el puente de la purísima, viajamos al sur de Francia con los cuñados viendo varios mercados navideños, sumergiéndonos en un ambiente navideño y lleno de tradición. Concretamente visitamos: Peyriac-de-Mer, Barcares, Perpignan, Carcasonne, Narbona, Beziers y Collioure. Itensidad a tope y rincones preciosos en cuatro días para entrar en las fiestas navideñas por todo lo alto.
Y en cuanto al hockey, tanto Roc como Nil siguen con una motivación desbordante. Este año, junto con otros padres, nos involucramos más en la junta del club C.E. Torrelavit para preservar el hockey patines, una actividad que podría haber desaparecido. Fue un esfuerzo que valió la pena, ya que el equipo ha tenido una temporada excepcional, terminando invictos y en primera posición en la primera parte de la liga. Ha sido un año de desafíos, pero también de grandes satisfacciones y nuevos descubrimientos.
Charlas y escuelas de negocios
Este año también tuve el honor de participar en el podcast de Walker Reynolds, un referente en Industria 4.0, gracias a la intervención de Marc Pous. Poder compartir en este espacio ha sido una experiencia enriquecedora y una oportunidad para profundizar en temas que me apasionan.
Este ha sido mi segundo año como profesor en ESADE, he continuado impartiendo clases en las asignaturas de Digital Technology, Digital LABs y Capstone Projects II. Además este año he podido vivir la primera graduación de mis estudiantes. Verlos alcanzar sus objetivos ha sido enormemente motivador y un verdadero orgullo para mí.
Además de ESADE, este año he tenido la oportunidad de impartir clases en otras instituciones. En Tecnocampus Mataró, di una clase sobre IoT, mientras que en EAE Business School me centré en Key Enabling Technologies. También impartí clases para Damm y Simon en ISDI y repetí mi clase sobre Cloud en UCAM (Universidad Católica de Murcia).
En cuanto a charlas, este año he participado en varios eventos destacados. El 16 de mayo estuve en Feceminte hablando sobre las oportunidades de negocio de la Industria 4.0. El 25 de septiembre participé en una jornada de comercio y empresa organizada por el ayuntamiento de Sant Fruitós de Bages, y el 10 de noviembre tuve la oportunidad de estar en la 2ª Convención del Salou Congress.
Cada una de estas experiencias ha contribuido a mi crecimiento profesional y personal, permitiéndome compartir conocimientos y aprender de otros expertos en el campo.
Proyectos profesionales
Ha sido un año donde me he encontrado completamente inmerso en mis responsabilidades como consultor y mentor. Ha sido un reto significativo compaginar esta actividad con mis labores de docencia y formación. Mi agenda ha estado bastante saturada, dedicando cuatro días a la semana a tres clientes fijos, lo que ha limitado mi disponibilidad para otros proyectos.
Sin embargo, lo destacable de esta experiencia ha sido el enorme placer y aprendizaje que he obtenido trabajando con estos clientes: Sàbat, Nexiona e i2cat. Más que clientes, los considero compañeros de un viaje de aprendizaje mutuo. En cada paso que damos juntos, nos retroalimentamos, lo cual se refleja en el crecimiento conjunto y en la calidad de nuestro trabajo.
Quiero aprovechar para expresar mi más sincera gratitud a estos clientes por la confianza depositada en mí. Su apoyo no solo ha contribuido a mi desarrollo profesional, sino que también ha enriquecido mi carrera de maneras que no había imaginado. Este año ha sido un testimonio del valor del trabajo en equipo, el aprendizaje constante y la colaboración efectiva.
Aprendizajes técnicos, ymbihq y otros derivados
Mi interés en el mundo del blockchain me llevó a realizar un curso de smart contracts (Solidity) en Lytryum. Este aprendizaje me ha proporcionado una base sólida y un entendimiento más profundo de las posibilidades que ofrece esta tecnología. Además de permitirme adentrar de lleno en el mundo crypto.
Sin embargo, el tema dominante del año ha sido la inteligencia artificial. En este campo, el aprendizaje más destacado ha sido con Langchain, una de esas librerías revolucionarias que cambian la forma en que entendemos y trabajamos con la IA.
En el ámbito del hardware y la infraestructura de red, he realizado cambios significativos en mi casa, implementando VLANs con nuevos switches y cableado. Además, he instalado una nueva red wifi basada en Ubiquiti (UDM Pro – Dream Machine), lo que ha mejorado notablemente la conectividad en el hogar. Resumiendo he pasado de tener 5 redes diferentes en casa con cada una de sus infraestructuras independientes a una sola red física que multiplexa las 5 redes virtuales aprovechando el mismo hardware.
En cuanto a software, he continuado mi aprendizaje y profundización en Kubernetes, Docker y Ansible, aumentando mi expertise en estas tecnologías.
Bajando a un tema muy concreto que vale la pena destacar; os comparto que al instalar las placas solares me pusieron dos smart meters de la marca Wibeee. Después de varios problemas de conectividad y de muchísimas horas de investigación junto al equipo del fabricante. Tengo que resaltar que estuve especialmente satisfecho con el nivel de conocimiento adquirido sobre cómo ha sido fabricado el smart meter Wibeee que tengo instalado. Y agradecer profundamente el soporte recibido por parte del equipo de Wibeee, simplemente excelente.
Gracias a mis clientes, también he tenido la oportunidad de aprender mucho sobre vídeo volumétrico, una tecnología emergente con un gran potencial en diversos campos. Realmente conocer este tema en cuanto a codec y tecnologías de transporte futuras como 6G es una delicia.
Finalmente, he profundizado en el ecosistema de servicios de Cloudflare, ampliando mi conocimiento en soluciones de nube y seguridad en línea.
Conclusión y cierre
Reflexionando sobre todo lo vivido en este 2023, puedo afirmar que ha sido un año de continuo crecimiento y aprendizaje. Desde las enseñanzas personales hasta los logros profesionales, cada experiencia ha contribuido a mi desarrollo integral como individuo y profesional.
Este año me ha enseñado el valor de la adaptación y la importancia de abrazar el cambio, tanto en el ámbito personal como en el profesional. He reafirmado mi pasión por enseñar, compartir conocimientos y aprender de otros, y cada clase, charla o proyecto ha sido una oportunidad para expandir mi visión y habilidades.
Los proyectos familiares, como la reforma de nuestra casa, y los viajes realizados, han reforzado los lazos con mis seres queridos y me han recordado que los momentos más valiosos se encuentran en las experiencias compartidas. Al mismo tiempo, mi compromiso con mis clientes y mi labor como consultor y mentor han reforzado mi convicción de que el trabajo en equipo y la colaboración son esenciales para el éxito.
En términos de aprendizaje técnico, he explorado nuevas fronteras en el mundo de la inteligencia artificial, la infraestructura de red y las tecnologías emergentes, lo que ha ampliado mi horizonte tecnológico y me ha preparado para los desafíos del futuro.
Este año también ha tenido sus momentos de melancolía, especialmente con la pérdida de un mentor y amigo querido. Su legado y enseñanzas seguirán siendo una fuente de inspiración y guía en mi camino.
En resumen, el 2023 ha sido un año de transformación y enriquecimiento. Me siento agradecido por cada experiencia vivida, por las personas que han formado parte de mi viaje y por todo lo que he aprendido. Con estos aprendizajes y experiencias, miro hacia el futuro con optimismo y entusiasmo, listo para abrazar los nuevos retos y oportunidades que traerá el 2024.
Dynaconf is a powerful configuration management library for Python that simplifies the process of managing and accessing application settings. It offers a wide range of features, including support for multiple configuration sources, environment variables, and dynamic reloading.
Main features:
Multiple configuration sources: Dynaconf can read settings from various sources, including environment variables, files, and even Vault servers. This flexibility allows you to centralize your configuration management and adapt to different deployment environments.
Environment variable support: Dynaconf seamlessly integrates with environment variables, making it easy to inject configuration values from your system or containerized environments.
Dynamic reloading: Dynaconf can dynamically reload configuration changes without restarting your application, ensuring that your application always reflects the latest settings.
Supported configuration file formats:
Dynaconf supports a variety of configuration file formats, including:
TOML (recommended)
YAML
JSON
INI
Python files
Installation:
Dynaconf can be installed using either pip or poetry:
pipinstalldynaconf# orpoetryadddynaconf
How to initialize Dynaconf
Dynaconf is a powerful configuration management library for Python that simplifies the process of managing and accessing application settings. It offers a wide range of features, including support for multiple configuration sources, environment variables, and dynamic reloading.
To initialize Dynaconf in your project, run the following command in your project’s root directory:
dynaconfinit-ftoml
This command will create the following files:
config.py: This file imports the Dynaconf settings object.
settings.toml: This file contains your application settings.
.secrets.toml: This file contains your sensitive data, such as passwords and tokens.
config.py
The config.py file is a Python file that imports the Dynaconf settings object. This file is required for Dynaconf to work.
Here is an example of a config.py file:
importdynaconfsettings = dynaconf.settings()
settings.toml
The settings.toml file contains your application settings. This file is optional, but it is the recommended way to store your settings.
Here is an example of a settings.toml file:
[default]debug=falsehost="localhost"port=5000
secrets.toml
The .secrets.toml file contains your sensitive data, such as passwords and tokens. This file is optional, but it is recommended to store your sensitive data in a separate file from your application settings.
Once you have initialized Dynaconf, you can import the settings object into your Python code. For example:
fromconfigimportsettings
You can then access your application settings using the settings object. For example:
setting_value=settings.get('KEY')
Dynaconf also supports accessing settings using attributes. For example:
setting_value=settings.KEY
Importing environment variables in Docker-Compose:
When using Dynaconf with Docker-Compose, the best strategy for importing environment variables is to define them in your docker-compose.yml file and then access them using Dynaconf’s envvar_prefix setting.
Dynaconf is a versatile and powerful configuration management library for Python that simplifies the process of managing and accessing application settings. Its comprehensive feature set and ease of use make it an ideal choice for a wide range of Python projects.
In today’s digital age, managing users and groups efficiently is essential for smooth computer operations. Windows 11, Microsoft’s latest OS, offers robust tools for this purpose. One of these is PowerShell, which allows for streamlined user and group management. Below, we dive deep into managing local users and groups using PowerShell in Windows 11.
1. Get Local Users List Using PowerShell
To retrieve a list of local users:
Get-LocalUser
2. Getting User List, Local and Non-local
For a comprehensive list that includes both local and non-local users, combine local user data with Active Directory information:
Get-LocalUser Get-ADUser -Filter *
(Note: The latter command requires the Active Directory module.)
3. Add and Remove User Using PowerShell
Adding a User:
New-LocalUser -Name "Username"-Description "Description of the User"-NoPassword
Removing a User:
Remove-LocalUser -Name "Username"
4. Manage Groups Using PowerShell
View all local groups:
Get-LocalGroup
Create a new group:
New-LocalGroup -Name "GroupName"-Description "Description of the Group"
In the modern era of hybrid working environments, securing remote connections is paramount. Windows 11, keeping pace with this need, facilitates the integration of OpenSSH server for a secure remote login, utilizing key-based authentication. This post delineates a step-by-step approach to set up OpenSSH server, manage key-based authentication, and handle service operations seamlessly using PowerShell.
Installing OpenSSH Server using PowerShell
Launch PowerShell as an Administrator.
Execute the following command to install OpenSSH Server:
Add-WindowsFeature -Name OpenSSH.Server
Once installed, you can check the installation with:
Get-WindowsFeature -Name OpenSSH.*
Managing SSH Public Key
For User Access:
Save the public key in C:\Users\<username>\.ssh\authorized_keys.
For Administrator Access:
Save the public key in C:\ProgramData\ssh\administrators_authorized_keys.
SSH-Agent is a background program that handles private key operations. It stores your private keys securely, requiring you to unlock them only once, thus easing the authentication process.
Generating SSH Key using PowerShell
ssh-keygen -t ed25519
Follow the on-screen instructions to specify a path and passphrase for your keys.
For using the stored keys in SSH Agent, just run a SSH client as always:
ssh username@server_address
By following the above-mentioned steps, you not only set up a robust OpenSSH server on Windows 11 but also ensure a secure remote connectivity through key-based authentication.
OpenWRT, the popular open-source Linux operating system designed for embedded devices, offers the LUCI interface for easy configuration and management. LUCI is essentially the web interface for OpenWRT, and while it’s already feature-rich, sometimes you may want to extend its functionalities based on your needs.
Recently, I had a requirement to enhance my OpenWRT LUCI interface. Specifically, I wanted to introduce a new menu named “Apps” in the LUCI dashboard. The objective was to have each entry within this new menu link to different applications installed on my device. And not just that! I wanted these application pages to pop open in new tabs for ease of access.
The Solution
The changes were made in a single file located at:
/usr/lib/lua/luci/controller/apps.lua
Within this file, I implemented the following code:
module("luci.controller.apps", package.seeall)function index() local page page =entry({"admin","apps"},firstchild(),_("Apps"),60) page.dependent = falseentry({"admin","apps","portainer"},call("serve_js_redirect","https","9443"),_("Portainer"),10).leaf = trueentry({"admin","apps","nodered"},call("serve_js_redirect","http","1880"),_("NodeRED"),20).leaf = trueentry({"admin","apps","grafana"},call("serve_js_redirect","http","3000"),_("Grafana"),30).leaf = trueentry({"admin","apps","prometheus"},call("serve_js_redirect","http","9090"),_("Prometheus"),40).leaf = trueendfunction serve_js_redirect(protocol, port) local ip = luci.http.getenv("SERVER_ADDR") local url = protocol .."://" .. ip ..":" .. port luci.http.prepare_content("text/html; charset=utf-8") luci.http.write("<!DOCTYPE html><html><head><meta charset='UTF-8'><title>Redirecting...</title></head><body>") luci.http.write("<script type='text/javascript'>") luci.http.write("window.onload = function() {") luci.http.write(" var newWindow = window.open('".. url .."', '_blank');") luci.http.write(" if (!newWindow || newWindow.closed || typeof newWindow.closed == 'undefined') {") luci.http.write(" document.getElementById('manualLink').style.display = 'block';") luci.http.write(" setTimeout(function() { window.location.href = document.referrer; }, 60000);")-- Redirigir después de 60 segundos luci.http.write(" }") luci.http.write("}") luci.http.write("</script>") luci.http.write("<p id='manualLink' style='display: none;'>The window didn't open automatically. <a href='".. url .."' target='_blank'>Click here</a> to open manually.</p>") luci.http.write("</body></html>")end
Key Points
The index function is responsible for defining the new menu and its entries.
The serve_js_redirect function creates a web page that uses JavaScript to automatically open the desired application in a new browser tab.
A failsafe mechanism is added in the form of a link. If, for any reason (like pop-up blockers), the new tab doesn’t open automatically, the user has the option to manually click on a link to open the application.
The script also includes a feature that will redirect the user back to the previous page after 60 seconds if the new tab doesn’t open.
This modification provides a seamless way to integrate external applications directly into the LUCI interface, making navigation and management even more convenient!
