#building a Docker image

[docker-official]

My student worker is putting docker inside a container, rather than run docker on the normal hardware. Get container'd nerd. -One of the Gimmick Blogs

IIRC the 'docker build' command does the same thing. In order to build the image it runs docker in docker.

And yes I am a container nerd thanks for noticing :p

[spiralmantra1]

A Comprehensive Guide to Deploy Azure Kubernetes Service with Azure Pipelines

A powerful orchestration tool for containerized applications is one such solution that Azure Kubernetes Service (AKS) has offered in the continuously evolving environment of cloud-native technologies. Associate this with Azure Pipelines for consistent CI CD workflows that aid in accelerating the DevOps process. This guide will dive into the deep understanding of Azure Kubernetes Service deployment with Azure Pipelines and give you tips that will enable engineers to build container deployments that work. Also, discuss how DevOps consulting services will help you automate this process.

Understanding the Foundations

Nowadays, Kubernetes is the preferred tool for running and deploying containerized apps in the modern high-speed software development environment. Together with AKS, it provides a high-performance scale and monitors and orchestrates containerized workloads in the environment. However, before anything, let’s deep dive to understand the fundamentals.

Azure Kubernetes Service: A managed Kubernetes platform that is useful for simplifying container orchestration. It deconstructs the Kubernetes cluster management hassles so that developers can build applications instead of infrastructure. By leveraging AKS, organizations can:

Deploy and scale containerized applications on demand.

Implement robust infrastructure management

Reduce operational overhead

Ensure high availability and fault tolerance.

Azure Pipelines: The CI/CD Backbone

The automated code building, testing, and disposition tool, combined with Azure Kubernetes Service, helps teams build high-end deployment pipelines in line with the modern DevOps mindset. Then you have Azure Pipelines for easily integrating with repositories (GitHub, Repos, etc.) and automating the application build and deployment.

Spiral Mantra DevOps Consulting Services

So, if you’re a beginner in DevOps or want to scale your organization’s capabilities, then DevOps consulting services by Spiral Mantra can be a game changer. The skilled professionals working here can help businesses implement CI CD pipelines along with guidance regarding containerization and cloud-native development.

Now let’s move on to creating a deployment pipeline for Azure Kubernetes Service.

Prerequisites you would require

Before initiating the process, ensure you fulfill the prerequisite criteria:

Service Subscription: To run an AKS cluster, you require an Azure subscription. Do create one if you don’t already.

CLI: The Azure CLI will let you administer resources such as AKS clusters from the command line.

A Professional Team: You will need to have a professional team with technical knowledge to set up the pipeline. Hire DevOps developers from us if you don’t have one yet.

Kubernetes Cluster: Deploy an AKS cluster with Azure Portal or ARM template. This will be the cluster that you run your pipeline on.

Docker: Since you’re deploying containers, you need Docker installed on your machine locally for container image generation and push.

Step-by-Step Deployment Process

Step 1: Begin with Creating an AKS Cluster

Simply begin the process by setting up an AKS cluster with CLI or Azure Portal. Once the process is completed, navigate further to execute the process of application containerization, and for that, you would need to create a Docker file with the specification of your application runtime environment. This step is needed to execute the same code for different environments.

Step 2: Setting Up Your Pipelines

Now, the process can be executed for new projects and for already created pipelines, and that’s how you can go further.

Create a New Project

Begin with launching the Azure DevOps account; from the screen available, select the drop-down icon.

Now, tap on the Create New Project icon or navigate further to use an existing one.

In the final step, add all the required repositories (you can select them either from GitHub or from Azure Repos) containing your application code.

For Already Existing Pipeline

Now, from your existing project, tap to navigate the option mentioning Pipelines, and then open Create Pipeline.

From the next available screen, select the repository containing the code of the application.

Navigate further to opt for either the YAML pipeline or the starter pipeline. (Note: The YAML pipeline is a flexible environment and is best recommended for advanced workflows.).

Further, define pipeline configuration by accessing your YAML file in Azure DevOps.

Step 3: Set Up Your Automatic Continuous Deployment (CD)

Further, in the next step, you would be required to automate the deployment process to fasten the CI CD workflows. Within the process, the easiest and most common approach to execute the task is to develop a YAML file mentioning deployment.yaml. This step is helpful to identify and define the major Kubernetes resources, including deployments, pods, and services.

After the successful creation of the YAML deployment, the pipeline will start to trigger the Kubernetes deployment automatically once the code is pushed.

Step 4: Automate the Workflow of CI CD

Now that we have landed in the final step, it complies with the smooth running of the pipelines every time the new code is pushed. With the right CI CD integration, the workflow allows for the execution of continuous testing and building with the right set of deployments, ensuring that the applications are updated in every AKS environment.

Best Practices for AKS and Azure Pipelines Integration

1. Infrastructure as Code (IaC)

- Utilize Terraform or Azure Resource Manager templates

- Version control infrastructure configurations

- Ensure consistent and reproducible deployments

2. Security Considerations

- Implement container scanning

- Use private container registries

- Regular security patch management

- Network policy configuration

3. Performance Optimization

- Implement horizontal pod autoscaling

- Configure resource quotas

- Use node pool strategies

- Optimize container image sizes

Common Challenges and Solutions

Network Complexity

Utilize Azure CNI for advanced networking

Implement network policies

Configure service mesh for complex microservices

Persistent Storage

Use Azure Disk or Files

Configure persistent volume claims

Implement storage classes for dynamic provisioning

Conclusion

Deploying the Azure Kubernetes Service with effective pipelines represents an explicit approach to the final application delivery. By embracing these practices, DevOps consulting companies like Spiral Mantra offer transformative solutions that foster agile and scalable approaches. Our expert DevOps consulting services redefine technological infrastructure by offering comprehensive cloud strategies and Kubernetes containerization with advanced CI CD integration.

Let’s connect and talk about your cloud migration needs

[govindhtech]

Open Platform For Enterprise AI Avatar Chatbot Creation

How may an AI avatar chatbot be created using the Open Platform For Enterprise AI framework?

I. Flow Diagram

The graph displays the application’s overall flow. The Open Platform For Enterprise AI GenAIExamples repository’s “Avatar Chatbot” serves as the code sample. The “AvatarChatbot” megaservice, the application’s central component, is highlighted in the flowchart diagram. Four distinct microservices Automatic Speech Recognition (ASR), Large Language Model (LLM), Text-to-Speech (TTS), and Animation are coordinated by the megaservice and linked into a Directed Acyclic Graph (DAG).

Every microservice manages a specific avatar chatbot function. For instance:

Software for voice recognition that translates spoken words into text is called Automatic Speech Recognition (ASR).

By comprehending the user’s query, the Large Language Model (LLM) analyzes the transcribed text from ASR and produces the relevant text response.

The text response produced by the LLM is converted into audible speech by a text-to-speech (TTS) service.

The animation service makes sure that the lip movements of the avatar figure correspond with the synchronized speech by combining the audio response from TTS with the user-defined AI avatar picture or video. After then, a video of the avatar conversing with the user is produced.

An audio question and a visual input of an image or video are among the user inputs. A face-animated avatar video is the result. By hearing the audible response and observing the chatbot’s natural speech, users will be able to receive input from the avatar chatbot that is nearly real-time.

Create the “Animation” microservice in the GenAIComps repository

We would need to register a new microservice, such “Animation,” under comps/animation in order to add it:

Register the microservice

@register_microservice( name=”opea_service@animation”, service_type=ServiceType.ANIMATION, endpoint=”/v1/animation”, host=”0.0.0.0″, port=9066, input_datatype=Base64ByteStrDoc, output_datatype=VideoPath, ) @register_statistics(names=[“opea_service@animation”])

It specify the callback function that will be used when this microservice is run following the registration procedure. The “animate” function, which accepts a “Base64ByteStrDoc” object as input audio and creates a “VideoPath” object with the path to the generated avatar video, will be used in the “Animation” case. It send an API request to the “wav2lip” FastAPI’s endpoint from “animation.py” and retrieve the response in JSON format.

Remember to import it in comps/init.py and add the “Base64ByteStrDoc” and “VideoPath” classes in comps/cores/proto/docarray.py!

This link contains the code for the “wav2lip” server API. Incoming audio Base64Str and user-specified avatar picture or video are processed by the post function of this FastAPI, which then outputs an animated video and returns its path.

The functional block for its microservice is created with the aid of the aforementioned procedures. It must create a Dockerfile for the “wav2lip” server API and another for “Animation” to enable the user to launch the “Animation” microservice and build the required dependencies. For instance, the Dockerfile.intel_hpu begins with the PyTorch* installer Docker image for Intel Gaudi and concludes with the execution of a bash script called “entrypoint.”

Create the “AvatarChatbot” Megaservice in GenAIExamples

The megaservice class AvatarChatbotService will be defined initially in the Python file “AvatarChatbot/docker/avatarchatbot.py.” Add “asr,” “llm,” “tts,” and “animation” microservices as nodes in a Directed Acyclic Graph (DAG) using the megaservice orchestrator’s “add” function in the “add_remote_service” function. Then, use the flow_to function to join the edges.

Specify megaservice’s gateway

An interface through which users can access the Megaservice is called a gateway. The Python file GenAIComps/comps/cores/mega/gateway.py contains the definition of the AvatarChatbotGateway class. The host, port, endpoint, input and output datatypes, and megaservice orchestrator are all contained in the AvatarChatbotGateway. Additionally, it provides a handle_request function that plans to send the first microservice the initial input together with parameters and gathers the response from the last microservice.

In order for users to quickly build the AvatarChatbot backend Docker image and launch the “AvatarChatbot” examples, we must lastly create a Dockerfile. Scripts to install required GenAI dependencies and components are included in the Dockerfile.

II. Face Animation Models and Lip Synchronization

GFPGAN + Wav2Lip

A state-of-the-art lip-synchronization method that uses deep learning to precisely match audio and video is Wav2Lip. Included in Wav2Lip are:

A skilled lip-sync discriminator that has been trained and can accurately identify sync in actual videos

A modified LipGAN model to produce a frame-by-frame talking face video

An expert lip-sync discriminator is trained using the LRS2 dataset as part of the pretraining phase. To determine the likelihood that the input video-audio pair is in sync, the lip-sync expert is pre-trained.

A LipGAN-like architecture is employed during Wav2Lip training. A face decoder, a visual encoder, and a speech encoder are all included in the generator. Convolutional layer stacks make up all three. Convolutional blocks also serve as the discriminator. The modified LipGAN is taught similarly to previous GANs: the discriminator is trained to discriminate between frames produced by the generator and the ground-truth frames, and the generator is trained to minimize the adversarial loss depending on the discriminator’s score. In total, a weighted sum of the following loss components is minimized in order to train the generator:

A loss of L1 reconstruction between the ground-truth and produced frames

A breach of synchronization between the lip-sync expert’s input audio and the output video frames

Depending on the discriminator score, an adversarial loss between the generated and ground-truth frames

After inference, it provide the audio speech from the previous TTS block and the video frames with the avatar figure to the Wav2Lip model. The avatar speaks the speech in a lip-synced video that is produced by the trained Wav2Lip model.

Lip synchronization is present in the Wav2Lip-generated movie, although the resolution around the mouth region is reduced. To enhance the face quality in the produced video frames, it might optionally add a GFPGAN model after Wav2Lip. The GFPGAN model uses face restoration to predict a high-quality image from an input facial image that has unknown deterioration. A pretrained face GAN (like Style-GAN2) is used as a prior in this U-Net degradation removal module. A more vibrant and lifelike avatar representation results from prettraining the GFPGAN model to recover high-quality facial information in its output frames.

SadTalker

It provides another cutting-edge model option for facial animation in addition to Wav2Lip. The 3D motion coefficients (head, stance, and expression) of a 3D Morphable Model (3DMM) are produced from audio by SadTalker, a stylized audio-driven talking-head video creation tool. The input image is then sent through a 3D-aware face renderer using these coefficients, which are mapped to 3D key points. A lifelike talking head video is the result.

Intel made it possible to use the Wav2Lip model on Intel Gaudi Al accelerators and the SadTalker and Wav2Lip models on Intel Xeon Scalable processors.

Read more on Govindhtech.com

[bluellab]

How to Choose the Right Tech Stack for Your Web App in 2025

In this article, you’ll learn how to confidently choose the right tech stack for your web app, avoid common mistakes, and stay future-proof. Whether you're building an MVP or scaling a SaaS platform, we’ll walk through every critical decision.

What Is a Tech Stack? (And Why It Matters More Than Ever)

Let’s not overcomplicate it. A tech stack is the combination of technologies you use to build and run a web app. It includes:

Front-end: What users see (e.g., React, Vue, Angular)

Back-end: What makes things work behind the scenes (e.g., Node.js, Django, Laravel)

Databases: Where your data lives (e.g., PostgreSQL, MongoDB, MySQL)

DevOps & Hosting: How your app is deployed and scaled (e.g., Docker, AWS, Vercel)

Why it matters: The wrong stack leads to poor performance, higher development costs, and scaling issues. The right stack supports speed, security, scalability, and a better developer experience.

Step 1: Define Your Web App’s Core Purpose

Before choosing tools, define the problem your app solves.

Is it data-heavy like an analytics dashboard?

Real-time focused, like a messaging or collaboration app?

Mobile-first, for customers on the go?

AI-driven, using machine learning in workflows?

Example: If you're building a streaming app, you need a tech stack optimized for media delivery, latency, and concurrent user handling.

Need help defining your app’s vision? Bluell AB’s Web Development service can guide you from idea to architecture.

Step 2: Consider Scalability from Day One

Most startups make the mistake of only thinking about MVP speed. But scaling problems can cost you down the line.

Here’s what to keep in mind:

Stateless architecture supports horizontal scaling

Choose microservices or modular monoliths based on team size and scope

Go for asynchronous processing (e.g., Node.js, Python Celery)

Use CDNs and caching for frontend optimization

A poorly optimized stack can increase infrastructure costs by 30–50% during scale. So, choose a stack that lets you scale without rewriting everything.

Step 3: Think Developer Availability & Community

Great tech means nothing if you can’t find people who can use it well.

Ask yourself:

Are there enough developers skilled in this tech?

Is the community strong and active?

Are there plenty of open-source tools and integrations?

Example: Choosing Go or Elixir might give you performance gains, but hiring developers can be tough compared to React or Node.js ecosystems.

Step 4: Match the Stack with the Right Architecture Pattern

Do you need:

A Monolithic app? Best for MVPs and small teams.

A Microservices architecture? Ideal for large-scale SaaS platforms.

A Serverless model? Great for event-driven apps or unpredictable traffic.

Pro Tip: Don’t over-engineer. Start with a modular monolith, then migrate as you grow.

Step 5: Prioritize Speed and Performance

In 2025, user patience is non-existent. Google says 53% of mobile users leave a page that takes more than 3 seconds to load.

To ensure speed:

Use Next.js or Nuxt.js for server-side rendering

Optimize images and use lazy loading

Use Redis or Memcached for caching

Integrate CDNs like Cloudflare

Benchmark early and often. Use tools like Lighthouse, WebPageTest, and New Relic to monitor.

Step 6: Plan for Integration and APIs

Your app doesn’t live in a vacuum. Think about:

Payment gateways (Stripe, PayPal)

CRM/ERP tools (Salesforce, HubSpot)

3rd-party APIs (OpenAI, Google Maps)

Make sure your stack supports REST or GraphQL seamlessly and has robust middleware for secure integration.

Step 7: Security and Compliance First

Security can’t be an afterthought.

Use stacks that support JWT, OAuth2, and secure sessions

Make sure your database handles encryption-at-rest

Use HTTPS, rate limiting, and sanitize inputs

Data breaches cost startups an average of $3.86 million. Prevention is cheaper than reaction.

Step 8: Don’t Ignore Cost and Licensing

Open source doesn’t always mean free. Some tools have enterprise licenses, usage limits, or require premium add-ons.

Cost checklist:

Licensing (e.g., Firebase becomes costly at scale)

DevOps costs (e.g., AWS vs. DigitalOcean)

Developer productivity (fewer bugs = lower costs)

Budgeting for technology should include time to hire, cost to scale, and infrastructure support.

Step 9: Understand the Role of DevOps and CI/CD

Continuous integration and continuous deployment (CI/CD) aren’t optional anymore.

Choose a tech stack that:

Works well with GitHub Actions, GitLab CI, or Jenkins

Supports containerization with Docker and Kubernetes

Enables fast rollback and testing

This reduces downtime and lets your team iterate faster.

Step 10: Evaluate Real-World Use Cases

Here’s how popular stacks perform:

Look at what companies are using, then adapt, don’t copy blindly.

How Bluell Can Help You Make the Right Tech Choice

Choosing a tech stack isn’t just technical, it’s strategic. Bluell specializes in full-stack development and helps startups and growing companies build modern, scalable web apps. Whether you’re validating an MVP or building a SaaS product from scratch, we can help you pick the right tools from day one.

Conclusion

Think of your tech stack like choosing a foundation for a building. You don’t want to rebuild it when you’re five stories up.

Here’s a quick recap to guide your decision:

Know your app’s purpose

Plan for future growth

Prioritize developer availability and ecosystem

Don’t ignore performance, security, or cost

Lean into CI/CD and DevOps early

Make data-backed decisions, not just trendy ones

Make your tech stack work for your users, your team, and your business, not the other way around.

[this-week-in-rust]

This Week in Rust 598

Hello and welcome to another issue of This Week in Rust! Rust is a programming language empowering everyone to build reliable and efficient software. This is a weekly summary of its progress and community. Want something mentioned? Tag us at @thisweekinrust.bsky.social on Bluesky or @ThisWeekinRust on mastodon.social, or send us a pull request. Want to get involved? We love contributions.

This Week in Rust is openly developed on GitHub and archives can be viewed at this-week-in-rust.org. If you find any errors in this week's issue, please submit a PR.

Want TWIR in your inbox? Subscribe here.

Updates from Rust Community

Official

Announcing rustup 1.28.2

Project/Tooling Updates

Announcing Malai - Share your dev server (and more) over P2P

Streaming data analytics, Fluvio 0.17.2 release

Leptos v0.8.0

This Month in Redox - April 2025

Observations/Thoughts

Automatic interleaving of high-level concurrent operations

Flattening Rust's Learning Curve

The Evolution of Rust

std::mem is... interesting

[audio] Svix with Tom Hacohen

Rust Walkthroughs

Authentication with Axum

Newtyped Indices are Proofs

What is my fuzzer doing?

A Rust API Inspired by Python, Powered by Serde

How to create small and secure Docker images for Rust (FROM scratch)

[video] Rust + SQLite: Complete Tutorial (Schema, CRUD, JSON & Async)

Research

An Interactive Debugger for Rust Trait Errors

RustAssistant: Using LLMs to Fix Compilation Errors in Rust Code

Miscellaneous

Memory-safe sudo to become the default in Ubuntu

How To Get A Rust Job Part I: Companies Already Using Rust

GOSIM Spotlight Finalists at RustWeek

Crate of the Week

This week's crate is structstruck, a proc-macro crate for enabling nested struct/enum definitions.

Thanks to Julius Michaelis for the self-suggestion!

Please submit your suggestions and votes for next week!

Calls for Testing

An important step for RFC implementation is for people to experiment with the implementation and give feedback, especially before stabilization.

If you are a feature implementer and would like your RFC to appear in this list, add a call-for-testing label to your RFC along with a comment providing testing instructions and/or guidance on which aspect(s) of the feature need testing.

No calls for testing were issued this week by Rust, Rust language RFCs or Rustup.

Let us know if you would like your feature to be tracked as a part of this list.

RFCs

Rust

Rustup

If you are a feature implementer and would like your RFC to appear on the above list, add the new call-for-testing label to your RFC along with a comment providing testing instructions and/or guidance on which aspect(s) of the feature need testing.

Call for Participation; projects and speakers

CFP - Projects

Always wanted to contribute to open-source projects but did not know where to start? Every week we highlight some tasks from the Rust community for you to pick and get started!

Some of these tasks may also have mentors available, visit the task page for more information.

* Hyperswitch - Move connector-specific utility functions to respective connector modules * Hyperswitch - Refactor ACI connector to reuse utilities from utils.rs * Hyperswitch - Analyze and remove unused functions in connector/utils.rs * rama - add ffi/rama-rhai: support ability to use services and layers written in rhai * rama - support (TLS) peetprint in rama-net fingerprinting * rama - support akamai h2 passive fingerprint and expose in echo + fp services * rama - add into_stream to BodyExtractExt trait

If you are a Rust project owner and are looking for contributors, please submit tasks here or through a PR to TWiR or by reaching out on X (formerly Twitter) or Mastodon!

CFP - Events

Are you a new or experienced speaker looking for a place to share something cool? This section highlights events that are being planned and are accepting submissions to join their event as a speaker.

No Calls for papers or presentations were submitted this week.

If you are an event organizer hoping to expand the reach of your event, please submit a link to the website through a PR to TWiR or by reaching out on X (formerly Twitter) or Mastodon!

Updates from the Rust Project

447 pull requests were merged in the last week

Compiler

handle paren in macro expand for let-init-else expr

implement or-patterns for pattern types

initial support for dynamically linked crates

mir-opt: execute MatchBranchSimplification after GVN

refactor rustc_on_unimplemented's filter parser

perf: optimize the codegen for Span::from_expansion

perf: delay checking of #[rustc_no_implicit_autorefs] in autoref lint

perf: simplify LazyAttrTokenStream

perf: use a closure instead of three chained iterators

transmutability: merge contiguous runs with a common destination

transmutability: uninit transition matches unit byte only

Library

avoid redundant WTF-8 checks in PathBuf

delegate to inner vec::IntoIter from env::ArgsOs

implement Iterator::last for vec::IntoIter

stabilize ptr::swap_nonoverlapping in const

stabilize select_unpredictable

streamline the format macro

Cargo

cargo add: suggest similarly named features

in package-workspace, keep dev-dependencies if they have a version

Rustdoc

fix doctest heuristic for main fn wrapping

Rustfmt

also allow bool literals as first item of let chain

Clippy

don't warn about unloaded crates

fix collapsible_if false positive on block stmt before expr

fix manual_unwrap_or_default false positive on ref binding

fix: manual_slice_fill false positive on IndexMut overload

fix: unused_async false positive on default impl

gate collapsible_if let_chains lints on edition 2024 and MSRV

Rust-Analyzer

add PGO support to install

better handle parallelism in cache priming

disable fixpoint for variance computation temporarily

add an assist to unwrap a type with a generic arg

correct assoc ty bound var starting index

correct span info for mir::Operand

don't panic on some weird code

fix move_bounds assists not working for lifetimes

fix incorrect handling of unresolved non-module imports in name resolution

fix proc-macro API creating malformed negative literals

implement mut to const ptr cast for method resolution

improve parser recovery a bit

negative nums in concat! expansion

remove unnecessary token length check for macros in renaming

improve the let code snippet

render more lifetimes

support environment variable CARGO_MANIFEST_PATH

Rust Compiler Performance Triage

A relatively noisy week due to addition of new benchmarks as part of our 2025 benchmark update, and a number of large regressions in a rollup landing late in the week (and so not yet investigated).

Triage done by @simulacrum. Revision range: 25cdf1f6..62c5f58f

2 Regressions, 2 Improvements, 6 Mixed; 3 of them in rollups 31 artifact comparisons made in total

Full report here.

Approved RFCs

Changes to Rust follow the Rust RFC (request for comments) process. These are the RFCs that were approved for implementation this week:

No RFCs were approved this week.

Final Comment Period

Every week, the team announces the 'final comment period' for RFCs and key PRs which are reaching a decision. Express your opinions now.

Tracking Issues & PRs

Rust

Temporary lifetime extension through tuple struct and tuple variant constructors

Stabilize the avx512 target features

Make missing_fragment_specifier an unconditional error

Error on recursive opaque ty in HIR typeck

Add std::io::Seek instance for std::io::Take

remove intrinsics::drop_in_place

Stabilize tcp_quickack

Change the desugaring of assert! for better error output

[Tracking Issue for non_null_from_ref](https://github.com/rust-lang/rust/issues/130823)

Make well-formedness predicates no longer coinductive

Fix parameter order for _by() variants of min / max/ minmax in std::cmp

Finalize repeat expr inference behaviour with inferred repeat counts

Implement (part of) ACP 429: add DerefMut to Lazy[Cell/Lock]

Other Areas

Cargo

Stabilize doctest-xcompile

Rust RFCs

RFC: map_or_default in Option and Result

No Items entered Final Comment Period this week for Language Reference, Language Team or Unsafe Code Guidelines.

Let us know if you would like your PRs, Tracking Issues or RFCs to be tracked as a part of this list.

New and Updated RFCs

RFC: enable derive(From) for single-field structs

#![register_{attribute,lint}_tool]

RFC: Add an attribute for raising the alignment of various items

Upcoming Events

Rusty Events between 2025-05-07 - 2025-06-04 🦀

Virtual

2025-05-07 | Virtual (Indianapolis, IN, US) | Indy Rust

Indy.rs - with Social Distancing

2025-05-07 | Virtual (Rotterdam, NL) | Bevy Game Development

Bevy Meetup #10

2025-05-08 | Virtual (Berlin, DE) | Rust Berlin

Rust Hack and Learn

2025-05-08 | Virtual (Girona, ES) | Rust Girona

Sessió setmanal de codificació / Weekly coding session

2025-05-08 | Virtual (Tel Aviv-Yafo, IL) | Rust 🦀 TLV

שיחה חופשית ווירטואלית על ראסט

2025-05-08 | Virtual (Zürich, CH) | Rust Zürisee

🦀 Celebrating 10 years of Rust 1.0 (co-event with berline.rs) 🦀

2025-05-10 | Virtual | Leptos Community

Leptos Meetup: 0.8 Release and Server Fn Websockets Demo

2025-05-11 | Virtual (Dallas, TX, US) | Dallas Rust User Meetup

Rust Readers Discord Discussion: Async Rust

2025-05-11 | Virtual (Dallas, TX, US) | Dallas Rust User Meetup

Rust Readers Discord Discussion: Async Rust

2025-05-13 | Virtual (Dallas, TX, US) | Dallas Rust User Meetup

Second Tuesday

2025-05-15 | Hybrid (Redmond, WA, US) | Seattle Rust User Group

May, 2025 SRUG (Seattle Rust User Group) Meetup

2025-05-15 | Virtual (Joint Meetup, Europe + Israel) | Rust Berlin, Rust Paris, London Rust Project Group, Rust Zürisee, Rust TLV, Rust Nürnberg, Rust Munich, Rust Aarhus, lunch.rs

🦀 Celebrating 10 years of Rust 1.0 🦀

2025-05-15 | Virtual (Girona, ES) | Rust Girona

Sessió setmanal de codificació / Weekly coding session

2025-05-18 | Virtual (Dallas, TX, US) | Dallas Rust User Meetup

Rust Readers Discord Discussion: Async Rust

2025-05-19 | Virtual (Tel Aviv-Yafo, IL) | Rust 🦀 TLV

Tauri: Cross-Platform desktop applications with Rust and web technologies

2025-05-20 | Virtual (London, UK) | Women in Rust

Threading through lifetimes of borrowing - the Rust way

2025-05-20 | Virtual (Tel Aviv, IL) | Code Mavens 🦀 - 🐍 - 🐪

Rust at Work a conversation with Ran Reichman Co-Founder & CEO of Flarion

2025-05-20 | Virtual (Washington, DC, US) | Rust DC

Mid-month Rustful

2025-05-21 | Hybrid (Vancouver, BC, CA) | Vancouver Rust

Rust Study/Hack/Hang-out

2025-05-22 | Virtual (Berlin, DE) | Rust Berlin

Rust Hack and Learn

2025-05-22 | Virtual (Girona, ES) | Rust Girona

Sessió setmanal de codificació / Weekly coding session

2025-05-25 | Virtual (Dallas, TX, US) | Dallas Rust User Meetup

Rust Readers Discord Discussion: Async Rust

2025-05-25 | Virtual (Dallas, TX, US) | Dallas Rust User Meetup

Rust Readers Discord Discussion: Async Rust

2025-05-27 | Virtual (Dallas, TX, US) | Dallas Rust User Meetup

Fourth Tuesday

2025-05-27 | Virtual (Tel Aviv, IL) | Code Mavens 🦀 - 🐍 - 🐪

Rust at Work - conversation with Eli Shalom & Igal Tabachnik of Eureka Labs

2025-05-29 | Virtual (Nürnberg, DE) | Rust Nuremberg

Rust Nürnberg online

2025-06-01 | Virtual (Dallas, TX, US) | Dallas Rust User Meetup

Rust Readers Discord Discussion: Async Rust

2025-06-04 | Virtual (Indianapolis, IN, US) | Indy Rust

Indy.rs - with Social Distancing

Asia

2025-05-17 | Delhi, IN | Rust Delhi

Rust Delhi Meetup #10

2025-05-24 | Bangalore/Bengaluru, IN | Rust Bangalore

May 2025 Rustacean meetup

Europe

2025-05-07 | Girona, ES | Rust Girona

Rust Girona Hack & Learn 05 2025

2025-05-07 | Köln, DE | Rust Cologne

Rust in May: FFI

2025-05-07 | Madrid, ES | MadRust

VII Lenguajes, VII Perspectivas, I Problema

2025-05-07 | Oxford, UK | Oxford Rust Meetup Group

Oxford Rust and C++ social

2025-05-08 | Gdansk, PL | Rust Gdansk

Rust Gdansk Meetup #8

2025-05-08 | London, UK | London Rust Project Group

Adopting Rust (Hosted by Lloyds bank)

2025-05-12 | Amsterdam, NL | RustNL

Bowling at Rust Week

2025-05-12 | Amsterdam, NL | RustNL

Create your rusty steel Rust logo!

2025-05-12 | Amsterdam, NL | RustNL

Walking Tour around Utrecht - Monday (afternoon)

2025-05-12 | Amsterdam, NL | RustNL

Walking Tour around Utrecht - Monday

2025-05-13 | Amsterdam, NL | RustNL

RustWeek 2025 announcement

2025-05-13 - 2025-05-17 | Utrecht, NL | Rust NL

RustWeek 2025

2025-05-14 | Reading, UK | Reading Rust Workshop

Reading Rust Meetup

2025-05-15 | Oslo, NO | Rust Oslo

Rust 10-year anniversary @ Appear

2025-05-16 | Amsterdam, NL | RustNL

Rust Week Hackathon

2025-05-16 | Utrecht, NL | Rust NL Meetup Group

RustWeek Hackathon

2025-05-17 | Amsterdam, NL | RustNL

Walking Tour around Utrecht - Saturday

2025-05-20 | Aarhus, DK | Rust Aarhus

Hack Night - Robot Edition

2025-05-20 | Leipzig, SN, DE | Rust - Modern Systems Programming in Leipzig

Topic TBD

2025-05-22 | Augsburg, DE | Rust Augsburg

Rust meetup #13

2025-05-22 | Bern, CH | Rust Bern

2025 Rust Talks Bern #3 @zentroom

2025-05-22 | Paris, FR | Rust Paris

Rust meetup #77

2025-05-22 | Stockholm, SE | Stockholm Rust

Rust Meetup @UXStream

2025-05-27 | Basel, CH | Rust Basel

Rust Meetup #11 @ Letsboot Basel

2025-05-29 | Oslo, NO | Rust Oslo

Rust Hack'n'Learn at Kampen Bistro

2025-06-04 | München, DE | Rust Munich

Rust Munich 2025 / 2 - Hacking Evening

2025-06-04 | Oxford, UK | Oxford Rust Meetup Group

Oxford Rust and C++ social

North America

2025-05-07 | Chicago, IL, US | Chicago Rust Meetup

Rust Happy Hour

2025-05-08 | México City, MX | Rust MX

Calculando con el compilador: Compiler time vs Run time. Introducción a uv

2025-05-08 | Portland, OR, US | PDXRust

Apache DataFusion: A Fast, Extensible, Modular Analytic Query Engine in Rust

2025-05-11 | Boston, MA, US | Boston Rust Meetup

Porter Square Rust Lunch, May 11

2025-05-13 | New York, NY, US | Rust NYC

Multi-Platform App in Rust @ Warp.dev && Verifying Rust's Stdlib @ CMU

2025-05-15 | Mountain View, CA, US | Hacker Dojo

RUST MEETUP at HACKER DOJO

2025-05-15 | Nashville, TN, US | Music City Rust Developers

Using Rust For Web Series 2 : Why you, Yes You. Should use Hyperscript!

2025-05-15 | Hybrid (Redmond, WA, US) | Seattle Rust User Group

May, 2025 SRUG (Seattle Rust User Group) Meetup

2025-05-20 | San Francisco, CA, US | San Francisco Rust Study Group

Rust Hacking in Person

2025-05-21 | Hybrid (Vancouver, BC, CA) | Vancouver Rust

Rust Study/Hack/Hang-out

2025-05-28 | Austin, TX, US | Rust ATX

Rust Lunch - Fareground

2025-05-29 | Atlanta, GA, US | Rust Atlanta

Rust-Atl

South America

2025-05-28 | Montevideo, DE, UY | Rust Meetup Uruguay

Primera meetup de Rust de 2025!

2025-05-31 | São Paulo, BR | Rust São Paulo Meetup

Encontro do Rust-SP na WillBank

If you are running a Rust event please add it to the calendar to get it mentioned here. Please remember to add a link to the event too. Email the Rust Community Team for access.

Jobs

Please see the latest Who's Hiring thread on r/rust

Quote of the Week

Well, the answer is basically yes. Our firmware is all Rust. Every component of our autonomy stack is Rust. Our app is 50% in Rust. And, our visualization tools are in Rust. Our production tools are in rust. The production QC software, which we ship to China, is in rust. Our internal websites are in rust. It's rust all over. We’ve drank the Rust Kool-Aid. In fact, there is no Python installed on the robots. This is not to dis Python at all, but it’s just simply not there.

We use Python for neural network training. But Python is boxed to that. Everything else is Rust. And, the advantage of using Rust exponentially builds up.

– Vivek Bagaria on filtra.io

Thanks to Brian Kung for the suggestion!

Please submit quotes and vote for next week!

This Week in Rust is edited by: nellshamrell, llogiq, cdmistman, ericseppanen, extrawurst, U007D, joelmarcey, mariannegoldin, bennyvasquez, bdillo

Email list hosting is sponsored by The Rust Foundation

Discuss on r/rust

[blubberquark]

Nothing encapsulates my misgivings with Docker as much as this recent story. I wanted to deploy a PyGame-CE game as a static executable, and that means compiling CPython and PyGame statically, and then linking the two together. To compile PyGame statically, I need to statically link it to SDL2, but because of SDL2 special features, the SDL2 code can be replaced with a different version at runtime.

I tried, and failed, to do this. I could compile a certain version of CPython, but some of the dependencies of the latest CPython gave me trouble. I could compile PyGame with a simple makefile, but it was more difficult with meson.

Instead of doing this by hand, I started to write a Dockerfile. It's just too easy to get this wrong otherwise, or at least not get it right in a reproducible fashion. Although everything I was doing was just statically compiled, and it should all have worked with a shell script, it didn't work with a shell script in practice, because cmake, meson, and autotools all leak bits and pieces of my host system into the final product. Some things, like libGL, should never be linked into or distributed with my executable.

I also thought that, if I was already working with static compilation, I could just link PyGame-CE against cosmopolitan libc, and have the SDL2 pieces replaced with a dynamically linked libSDL2 for the target platform.

I ran into some trouble. I asked for help online.

The first answer I got was "You should just use PyInstaller for deployment"

The second answer was "You should use Docker for application deployment. Just start with

FROM python:3.11

and go from there"

The others agreed. I couldn't get through to them.

It's the perfect example of Docker users seeing Docker as the solution for everything, even when I was already using Docker (actually Podman).

I think in the long run, Docker has already caused, and will continue to cause, these problems:

Over-reliance on containerisation is slowly making build processes, dependencies, and deployment more brittle than necessary, because it still works in Docker

Over-reliance on containerisation is making the actual build process outside of a container or even in a container based on a different image more painful, as well as multi-stage build processes when dependencies want to be built in their own containers

Container specifications usually don't even take advantage of a known static build environment, for example by hard-coding a makefile, negating the savings in complexity

[v-for-violet]

i fucking hate modern devops or whatever buzzword you use for this shit

i just wanna take my code, shove it in a goddamn docker image and deploy it to my own goddamn hardware

no PaaS bullshit, no yaml files, none of that bullshit

just

code -> build -> deploy

please 😭

[qcs01]

Unleashing Efficiency: Containerization with Docker

Introduction: In the fast-paced world of modern IT, agility and efficiency reign supreme. Enter Docker - a revolutionary tool that has transformed the way applications are developed, deployed, and managed. Containerization with Docker has become a cornerstone of contemporary software development, offering unparalleled flexibility, scalability, and portability. In this blog, we'll explore the fundamentals of Docker containerization, its benefits, and practical insights into leveraging Docker for streamlining your development workflow.

Understanding Docker Containerization: At its core, Docker is an open-source platform that enables developers to package applications and their dependencies into lightweight, self-contained units known as containers. Unlike traditional virtualization, where each application runs on its own guest operating system, Docker containers share the host operating system's kernel, resulting in significant resource savings and improved performance.

Key Benefits of Docker Containerization:

Portability: Docker containers encapsulate the application code, runtime, libraries, and dependencies, making them portable across different environments, from development to production.

Isolation: Containers provide a high degree of isolation, ensuring that applications run independently of each other without interference, thus enhancing security and stability.

Scalability: Docker's architecture facilitates effortless scaling by allowing applications to be deployed and replicated across multiple containers, enabling seamless horizontal scaling as demand fluctuates.

Consistency: With Docker, developers can create standardized environments using Dockerfiles and Docker Compose, ensuring consistency between development, testing, and production environments.

Speed: Docker accelerates the development lifecycle by reducing the time spent on setting up development environments, debugging compatibility issues, and deploying applications.

Getting Started with Docker: To embark on your Docker journey, begin by installing Docker Desktop or Docker Engine on your development machine. Docker Desktop provides a user-friendly interface for managing containers, while Docker Engine offers a command-line interface for advanced users.

Once Docker is installed, you can start building and running containers using Docker's command-line interface (CLI). The basic workflow involves:

Writing a Dockerfile: A text file that contains instructions for building a Docker image, specifying the base image, dependencies, environment variables, and commands to run.

Building Docker Images: Use the docker build command to build a Docker image from the Dockerfile.

Running Containers: Utilize the docker run command to create and run containers based on the Docker images.

Managing Containers: Docker provides a range of commands for managing containers, including starting, stopping, restarting, and removing containers.

Best Practices for Docker Containerization: To maximize the benefits of Docker containerization, consider the following best practices:

Keep Containers Lightweight: Minimize the size of Docker images by removing unnecessary dependencies and optimizing Dockerfiles.

Use Multi-Stage Builds: Employ multi-stage builds to reduce the size of Docker images and improve build times.

Utilize Docker Compose: Docker Compose simplifies the management of multi-container applications by defining them in a single YAML file.

Implement Health Checks: Define health checks in Dockerfiles to ensure that containers are functioning correctly and automatically restart them if they fail.

Secure Containers: Follow security best practices, such as running containers with non-root users, limiting container privileges, and regularly updating base images to patch vulnerabilities.

Conclusion: Docker containerization has revolutionized the way applications are developed, deployed, and managed, offering unparalleled agility, efficiency, and scalability. By embracing Docker, developers can streamline their development workflow, accelerate the deployment process, and improve the consistency and reliability of their applications. Whether you're a seasoned developer or just getting started, Docker opens up a world of possibilities, empowering you to build and deploy applications with ease in today's fast-paced digital landscape.

For more details visit www.qcsdclabs.com

[holmoris]

Microsoft Scrimble Framework also comes in like 3 different variants that have wildly varying interfaces based on if they're built for .NET, .NET core 2.0 or .NET core 2.1. Only the .NET core 2.1 version is available via nuget, the rest have to be compiled from some guy's fork of Microsoft's git repository (you can't use the original because it's been marked as an archive, and the Microsoft team has moved over to committing to that guy's fork instead).

You're also forgetting pysqueeb-it, an insane combination of python packages that's only distributed as a dockerfile and builds into a monolithic single-command docker entrypoint. Thankfully all of this is pulled for you when you try to build the docker image but unfortunately the package also requires Torch for some inexplicable reason (i guess we're squeebing with tensors now?) so get ready to wait for an hour while pip pulls that alongside the other 200 packages in requirements.txt. Make sure you install version==2.1.3 and replace the relevant lines in the .env file with your public keys before the build, otherwise you get to do all this again in 2 hours (being a docker build, pip can't cache packages so it's going to pull torch and everything else again every single time).

every software is like. your mission-critical app requires you to use the scrimble protocol to squeeb some snorble files for sprongle expressions. do you use:

libsnorble-2-dev, a C library that the author only distributes as source code and therefore must be compiled from source using CMake

Squeeb.js, which sort of has most of the features you want, but requires about a gigabyte of Node dependencies and has only been in development for eight months and has 4.7k open issues on Github

Squeeh.js, a typosquatting trojan that uses your GPU to mine crypto if you install it by mistake

Sprongloxide, a Rust crate beloved by its fanatical userbase, which has been in version 0.9.* for about four years, and is actually just a thin wrapper for libsnorble-2-dev

GNU Scrimble, a GPLv3-licensed command-line tool maintained by the Free Software Foundation, which has over a hundred different flags, and also comes with an integrated Lisp interpreter for scripting, and also a TUI-based Pong implementation as an "easter egg", and also supports CSV, XML, JSON, PDF, XLSX, and even HTML files, but does not actually come with support for squeebing snorble files for ideological reasons. it does have a boomeresque drawing of a grinning meerkat as its logo, though

Microsoft Scrimble Framework Core, a .NET library that has all the features you need and more, but costs $399 anually and comes with a proprietary licensing agreement that grants Microsoft the right to tattoo advertisements on the inside of your eyelids

snorblite, a full-featured Perl module which is entirely developed and maintained by a single guy who is completely insane and constantly makes blog posts about how much he hates the ATF and the "woke mind-virus", but everyone uses it because it has all the features you need and is distributed under the MIT license

Google Squeebular (deprecated since 2017)

[docs-vultr-com]

install podman 5 on ubuntu 24.04

How to Install Podman 5 on Ubuntu 24.04 – A Step-by-Step Guide

Podman (Pod Manager) is a powerful container management tool that provides an alternative to Docker. With its rootless architecture, enhanced security, and OCI compliance, it has become a go-to tool for developers and sysadmins alike. In this guide, we’ll walk you through how to install Podman 5 on Ubuntu 24.04, enabling you to manage containers efficiently and securely.

What is Podman?

Podman is an open-source container engine that allows you to run, build, and manage containers and pods. Unlike Docker, Podman does not require a daemon to run in the background. Instead, it uses a fork/exec model which is lightweight and rootless by default. This makes it ideal for secure container operations, especially in enterprise environments.

Why Choose Podman 5 on Ubuntu 24.04?

Ubuntu 24.04, being one of the latest LTS (Long-Term Support) releases, comes with updated libraries, improved system performance, and strong security features. Combining this with Podman 5 gives you a modern, stable, and highly secure containerization environment.

Key Benefits of Using Podman:

Rootless containers for better security.

Docker CLI compatibility via alias docker=podman.

Systemd integration for managing containerized services.

Support for pods, making it ideal for Kubernetes-like workflows.

Prerequisites

Before installing Podman on Ubuntu 24.04, ensure the following:

A system running Ubuntu 24.04.

A non-root user with sudo privileges.

Internet access to download packages.

Step-by-Step: How to Install Podman 5 on Ubuntu 24.04

Step 1: Update the System

Open a terminal and ensure your system is up-to-date:

bash

CopyEdit

sudo apt update && sudo apt upgrade -y

This ensures you have the latest packages and security patches installed.

Step 2: Install Podman from Default Repositories

Ubuntu 24.04 includes Podman 5 in its default APT repositories. Install it using:

bash

CopyEdit

sudo apt install -y podman

This command installs the latest stable version of Podman along with all necessary dependencies.

Step 3: Verify the Installation

After installation, verify the Podman version to ensure it's correctly installed:

bash

CopyEdit

podman --version

You should see output similar to:

nginx

CopyEdit

podman version 5.0.x

This confirms that Podman 5 is successfully installed on your Ubuntu 24.04 machine.

Step 4: Running Your First Podman Container

Let’s run a simple container to test Podman:

bash

CopyEdit

podman run hello-world

This command pulls the hello-world image and runs it. If the setup is correct, you’ll see a message confirming that the container is running.

Step 5: Using Podman Without Root (Optional but Recommended)

One of Podman’s most important features is rootless container support. To use it:

Log in as a regular user (non-root).

Run:

bash

CopyEdit

podman info --debug

Look under rootless to verify if rootless mode is active.

You can now run containers securely without using sudo.

Step 6: Enabling Podman Services with systemd (Optional)

If you want to manage containers as background services using systemd, Podman integrates well:

bash

CopyEdit

podman generate systemd --name mycontainer --files --restart-policy=always

This generates a .service file that you can enable and start using systemctl.

Troubleshooting Tips

If Podman fails to run, make sure the package version is correct using apt policy podman.

Use podman logs to debug failed containers.

If DNS resolution fails in containers, check your system's /etc/resolv.conf and network settings.

Conclusion

Installing Podman 5 on Ubuntu 24.04 is straightforward and provides a modern, secure alternative to Docker. Whether you’re running a development environment or deploying applications in production, Podman’s rootless, daemon-less approach makes it ideal for secure container management.

With support for pods, systemd integration, and compatibility with Docker commands, Podman 5 is the future of containerization. Ubuntu 24.04’s performance and security improvements make it a perfect OS to run it on.

Learn More

You can follow the official Vultr guide here for additional details and configurations: 👉 https://docs.vultr.com/how-to-install-podman-on-ubuntu-24-04

[meguminmaniac]

I can see how someone might cut corners and not cross-compile or use a cross-building docker image and just dump the source code on the device to compile locally. But shipping a Raspberry Pi image logged into Slack is pretty wild.

first rule of software development is just deploy that shit baby

[this-week-in-rust]

This Week in Rust 516

Hello and welcome to another issue of This Week in Rust! Rust is a programming language empowering everyone to build reliable and efficient software. This is a weekly summary of its progress and community. Want something mentioned? Tag us at @ThisWeekInRust on Twitter or @ThisWeekinRust on mastodon.social, or send us a pull request. Want to get involved? We love contributions.

This Week in Rust is openly developed on GitHub and archives can be viewed at this-week-in-rust.org. If you find any errors in this week's issue, please submit a PR.

Updates from Rust Community

Official

Announcing Rust 1.73.0

Polonius update

Project/Tooling Updates

rust-analyzer changelog #202

Announcing: pid1 Crate for Easier Rust Docker Images - FP Complete

bit_seq in Rust: A Procedural Macro for Bit Sequence Generation

tcpproxy 0.4 released

Rune 0.13

Rust on Espressif chips - September 29 2023

esp-rs quarterly planning: Q4 2023

Implementing the #[diagnostic] namespace to improve rustc error messages in complex crates

Observations/Thoughts

Safety vs Performance. A case study of C, C++ and Rust sort implementations

Raw SQL in Rust with SQLx

Thread-per-core

Edge IoT with Rust on ESP: HTTP Client

The Ultimate Data Engineering Chadstack. Running Rust inside Apache Airflow

Why Rust doesn't need a standard div_rem: An LLVM tale - CodSpeed

Making Rust supply chain attacks harder with Cackle

[video] Rust 1.73.0: Everything Revealed in 16 Minutes

Rust Walkthroughs

Let's Build A Cargo Compatible Build Tool - Part 5

How we reduced the memory usage of our Rust extension by 4x

Calling Rust from Python

Acceptance Testing embedded-hal Drivers

5 ways to instantiate Rust structs in tests

Research

Looking for Bad Apples in Rust Dependency Trees Using GraphQL and Trustfall

Miscellaneous

Rust, Open Source, Consulting - Interview with Matthias Endler

Edge IoT with Rust on ESP: Connecting WiFi

Bare-metal Rust in Android

[audio] Learn Rust in a Month of Lunches with Dave MacLeod

[video] Rust 1.73.0: Everything Revealed in 16 Minutes

[video] Rust 1.73 Release Train

[video] Why is the JavaScript ecosystem switching to Rust?

Crate of the Week

This week's crate is yarer, a library and command-line tool to evaluate mathematical expressions.

Thanks to Gianluigi Davassi for the self-suggestion!

Please submit your suggestions and votes for next week!

Call for Participation

Always wanted to contribute to open-source projects but did not know where to start? Every week we highlight some tasks from the Rust community for you to pick and get started!

Some of these tasks may also have mentors available, visit the task page for more information.

Ockam - Make ockam node delete (no args) interactive by asking the user to choose from a list of nodes to delete (tuify)

Ockam - Improve ockam enroll ----help text by adding doc comment for identity flag (clap command)

Ockam - Enroll "email: '+' character not allowed"

If you are a Rust project owner and are looking for contributors, please submit tasks here.

Updates from the Rust Project

384 pull requests were merged in the last week

formally demote tier 2 MIPS targets to tier 3

add tvOS to target_os for register_dtor

linker: remove -Zgcc-ld option

linker: remove unstable legacy CLI linker flavors

non_lifetime_binders: fix ICE in lint opaque-hidden-inferred-bound

add async_fn_in_trait lint

add a note to duplicate diagnostics

always preserve DebugInfo in DeadStoreElimination

bring back generic parameters for indices in rustc_abi and make it compile on stable

coverage: allow each coverage statement to have multiple code regions

detect missing => after match guard during parsing

diagnostics: be more careful when suggesting struct fields

don't suggest nonsense suggestions for unconstrained type vars in note_source_of_type_mismatch_constraint

dont call mir.post_mono_checks in codegen

emit feature gate warning for auto traits pre-expansion

ensure that ~const trait bounds on associated functions are in const traits or impls

extend impl's def_span to include its where clauses

fix detecting references to packed unsized fields

fix fast-path for try_eval_scalar_int

fix to register analysis passes with -Zllvm-plugins at link-time

for a single impl candidate, try to unify it with error trait ref

generalize small dominators optimization

improve the suggestion of generic_bound_failure

make FnDef 1-ZST in LLVM debuginfo

more accurately point to where default return type should go

move subtyper below reveal_all and change reveal_all

only trigger refining_impl_trait lint on reachable traits

point to full async fn for future

print normalized ty

properly export function defined in test which uses global_asm!()

remove Key impls for types that involve an AllocId

remove is global hack

remove the TypedArena::alloc_from_iter specialization

show more information when multiple impls apply

suggest pin!() instead of Pin::new() when appropriate

make subtyping explicit in MIR

do not run optimizations on trivial MIR

in smir find_crates returns Vec<Crate> instead of Option<Crate>

add Span to various smir types

miri-script: print which sysroot target we are building

miri: auto-detect no_std where possible

miri: continuation of #3054: enable spurious reads in TB

miri: do not use host floats in simd_{ceil,floor,round,trunc}

miri: ensure RET assignments do not get propagated on unwinding

miri: implement llvm.x86.aesni.* intrinsics

miri: refactor dlsym: dispatch symbols via the normal shim mechanism

miri: support getentropy on macOS as a foreign item

miri: tree Borrows: do not create new tags as 'Active'

add missing inline attributes to Duration trait impls

stabilize Option::as_(mut_)slice

reuse existing Somes in Option::(x)or

fix generic bound of str::SplitInclusive's DoubleEndedIterator impl

cargo: refactor(toml): Make manifest file layout more consitent

cargo: add new package cache lock modes

cargo: add unsupported short suggestion for --out-dir flag

cargo: crates-io: add doc comment for NewCrate struct

cargo: feat: add Edition2024

cargo: prep for automating MSRV management

cargo: set and verify all MSRVs in CI

rustdoc-search: fix bug with multi-item impl trait

rustdoc: rename issue-\d+.rs tests to have meaningful names (part 2)

rustdoc: Show enum discrimant if it is a C-like variant

rustfmt: adjust span derivation for const generics

clippy: impl_trait_in_params now supports impls and traits

clippy: into_iter_without_iter: walk up deref impl chain to find iter methods

clippy: std_instead_of_core: avoid lint inside of proc-macro

clippy: avoid invoking ignored_unit_patterns in macro definition

clippy: fix items_after_test_module for non root modules, add applicable suggestion

clippy: fix ICE in redundant_locals

clippy: fix: avoid changing drop order

clippy: improve redundant_locals help message

rust-analyzer: add config option to use rust-analyzer specific target dir

rust-analyzer: add configuration for the default action of the status bar click action in VSCode

rust-analyzer: do flyimport completions by prefix search for short paths

rust-analyzer: add assist for applying De Morgan's law to Iterator::all and Iterator::any

rust-analyzer: add backtick to surrounding and auto-closing pairs

rust-analyzer: implement tuple return type to tuple struct assist

rust-analyzer: ensure rustfmt runs when configured with ./

rust-analyzer: fix path syntax produced by the into_to_qualified_from assist

rust-analyzer: recognize custom main function as binary entrypoint for runnables

Rust Compiler Performance Triage

A quiet week, with few regressions and improvements.

Triage done by @simulacrum. Revision range: 9998f4add..84d44dd

1 Regressions, 2 Improvements, 4 Mixed; 1 of them in rollups

68 artifact comparisons made in total

Full report here

Approved RFCs

Changes to Rust follow the Rust RFC (request for comments) process. These are the RFCs that were approved for implementation this week:

No RFCs were approved this week.

Final Comment Period

Every week, the team announces the 'final comment period' for RFCs and key PRs which are reaching a decision. Express your opinions now.

RFCs

[disposition: merge] RFC: Remove implicit features in a new edition

Tracking Issues & PRs

[disposition: merge] Bump COINDUCTIVE_OVERLAP_IN_COHERENCE to deny + warn in deps

[disposition: merge] document ABI compatibility

[disposition: merge] Broaden the consequences of recursive TLS initialization

[disposition: merge] Implement BufRead for VecDeque<u8>

[disposition: merge] Tracking Issue for feature(file_set_times): FileTimes and File::set_times

[disposition: merge] impl Not, Bit{And,Or}{,Assign} for IP addresses

[disposition: close] Make RefMut Sync

[disposition: merge] Implement FusedIterator for DecodeUtf16 when the inner iterator does

[disposition: merge] Stabilize {IpAddr, Ipv6Addr}::to_canonical

[disposition: merge] rustdoc: hide #[repr(transparent)] if it isn't part of the public ABI

New and Updated RFCs

[new] Add closure-move-bindings RFC

[new] RFC: Include Future and IntoFuture in the 2024 prelude

Call for Testing

An important step for RFC implementation is for people to experiment with the implementation and give feedback, especially before stabilization. The following RFCs would benefit from user testing before moving forward:

No RFCs issued a call for testing this week.

If you are a feature implementer and would like your RFC to appear on the above list, add the new call-for-testing label to your RFC along with a comment providing testing instructions and/or guidance on which aspect(s) of the feature need testing.

Upcoming Events

Rusty Events between 2023-10-11 - 2023-11-08 🦀

Virtual

2023-10-11| Virtual (Boulder, CO, US) | Boulder Elixir and Rust

Monthly Meetup

2023-10-12 - 2023-10-13 | Virtual (Brussels, BE) | EuroRust

EuroRust 2023

2023-10-12 | Virtual (Nuremberg, DE) | Rust Nuremberg

Rust Nürnberg online

2023-10-18 | Virtual (Cardiff, UK)| Rust and C++ Cardiff

Operating System Primitives (Atomics & Locks Chapter 8)

2023-10-18 | Virtual (Vancouver, BC, CA) | Vancouver Rust

Rust Study/Hack/Hang-out

2023-10-19 | Virtual (Charlottesville, NC, US) | Charlottesville Rust Meetup

Crafting Interpreters in Rust Collaboratively

2023-10-19 | Virtual (Stuttgart, DE) | Rust Community Stuttgart

Rust-Meetup

2023-10-24 | Virtual (Berlin, DE) | OpenTechSchool Berlin

Rust Hack and Learn | Mirror

2023-10-24 | Virtual (Washington, DC, US) | Rust DC

Month-end Rusting—Fun with 🍌 and 🔎!

2023-10-31 | Virtual (Dallas, TX, US) | Dallas Rust

Last Tuesday

2023-11-01 | Virtual (Indianapolis, IN, US) | Indy Rust

Indy.rs - with Social Distancing

Asia

2023-10-11 | Kuala Lumpur, MY | GoLang Malaysia

Rust Meetup Malaysia October 2023 | Event updates Telegram | Event group chat

2023-10-18 | Tokyo, JP | Tokyo Rust Meetup

Rust and the Age of High-Integrity Languages

Europe

2023-10-11 | Brussels, BE | BeCode Brussels Meetup

Rust on Web - EuroRust Conference

2023-10-12 - 2023-10-13 | Brussels, BE | EuroRust

EuroRust 2023

2023-10-12 | Brussels, BE | Rust Aarhus

Rust Aarhus - EuroRust Conference

2023-10-12 | Reading, UK | Reading Rust Workshop

Reading Rust Meetup at Browns

2023-10-17 | Helsinki, FI | Finland Rust-lang Group

Helsinki Rustaceans Meetup

2023-10-17 | Leipzig, DE | Rust - Modern Systems Programming in Leipzig

SIMD in Rust

2023-10-19 | Amsterdam, NL | Rust Developers Amsterdam Group

Rust Amsterdam Meetup @ Terraform

2023-10-19 | Wrocław, PL | Rust Wrocław

Rust Meetup #35

2023-09-19 | Virtual (Washington, DC, US) | Rust DC

Month-end Rusting—Fun with 🍌 and 🔎!

2023-10-25 | Dublin, IE | Rust Dublin

Biome, web development tooling with Rust

2023-10-26 | Augsburg, DE | Rust - Modern Systems Programming in Leipzig

Augsburg Rust Meetup #3

2023-10-26 | Delft, NL | Rust Nederland

Rust at TU Delft

2023-11-07 | Brussels, BE | Rust Aarhus

Rust Aarhus - Rust and Talk beginners edition

North America

2023-10-11 | Boulder, CO, US | Boulder Rust Meetup

First Meetup - Demo Day and Office Hours

2023-10-12 | Lehi, UT, US | Utah Rust

The Actor Model: Fearless Concurrency, Made Easy w/Chris Mena

2023-10-13 | Cambridge, MA, US | Boston Rust Meetup

Kendall Rust Lunch

2023-10-17 | San Francisco, CA, US | San Francisco Rust Study Group

Rust Hacking in Person

2023-10-18 | Brookline, MA, US | Boston Rust Meetup

Boston University Rust Lunch

2023-10-19 | Mountain View, CA, US | Mountain View Rust Meetup

Rust Meetup at Hacker Dojo

2023-10-19 | Nashville, TN, US | Music City Rust Developers

Rust Goes Where It Pleases Pt2 - Rust on the front end!

2023-10-19 | Seattle, WA, US | Seattle Rust User Group

Seattle Rust User Group - October Meetup

2023-10-25 | Austin, TX, US | Rust ATX

Rust Lunch - Fareground

2023-10-25 | Chicago, IL, US | Deep Dish Rust

Rust Happy Hour

Oceania

2023-10-17 | Christchurch, NZ | Christchurch Rust Meetup Group

Christchurch Rust meetup meeting

2023-10-26 | Brisbane, QLD, AU | Rust Brisbane

October Meetup

If you are running a Rust event please add it to the calendar to get it mentioned here. Please remember to add a link to the event too. Email the Rust Community Team for access.

Jobs

Please see the latest Who's Hiring thread on r/rust

Quote of the Week

The Rust mission -- let you write software that's fast and correct, productively -- has never been more alive. So next Rustconf, I plan to celebrate:

All the buffer overflows I didn't create, thanks to Rust

All the unit tests I didn't have to write, thanks to its type system

All the null checks I didn't have to write thanks to Option and Result

All the JS I didn't have to write thanks to WebAssembly

All the impossible states I didn't have to assert "This can never actually happen"

All the JSON field keys I didn't have to manually type in thanks to Serde

All the missing SQL column bugs I caught at compiletime thanks to Diesel

All the race conditions I never had to worry about thanks to the borrow checker

All the connections I can accept concurrently thanks to Tokio

All the formatting comments I didn't have to leave on PRs thanks to Rustfmt

All the performance footguns I didn't create thanks to Clippy

– Adam Chalmers in their RustConf 2023 recap

Thanks to robin for the suggestion!

Please submit quotes and vote for next week!

This Week in Rust is edited by: nellshamrell, llogiq, cdmistman, ericseppanen, extrawurst, andrewpollack, U007D, kolharsam, joelmarcey, mariannegoldin, bennyvasquez.

Email list hosting is sponsored by The Rust Foundation

Discuss on r/rust

[rootresident]

A Certifiable Hiccup

If you like this, check out my new dedicated blog site. I'm still posting here, but I'm shilling that as my primary blog.

So there I am, investigating a certificate issue. My wings nodes for running game servers with Pterodactyl are not checking in, and I've identified it as expired SSL certificates. No biggy, an easy fix to be sure, but why? I have automation in place to rotate certificates automatically, this shouldn't have happened at all. Cue a Discord notification. Then another. Then like 15 more, all saying the same thing: Service is down. Uh oh. It's immediately apparent that the cause of this is expired certifications, so I sigh and get a shell in the container which handles cert renewal and deployment.

Trying to run the playbook manually of course doesn't work, if it did then we wouldn't be here. The error is a bit strange though, Permission denied, unreachable. I'm reasonably confident SSH access is working fine... But we'll come back to that. I'm able to run the playbook from my laptop after getting the new cert from my storage server and tweaking a couple things, and the issue is fixed. Cool, outage resolved, now I just have to fix the issue in the container.

The service account is fine, I was able to use it when I ran the playbook from my laptop. And weirdly enough I can log in just fine from the container itself, so it's not a network issue there, which means it must be related to Ansible somehow. And since the playbook worked on my laptop, it must be an issue with Ansible on the container, specifically. Checking the obvious things, the env vars with the credentials are correct and work for the ssh command, so it's not that. I'm a bit concerned Ansible is mangling them somehow, but it's not simple to debug something before login, so to rule that out I make an attempt with the credentials hardcoded. Still no dice, so it's probably not that either.

After a good 30 minutes to an hour of trying random things, googling, recreating the container to rule out the possibility of some weird transient fuck up, something catches my eye. In my inventory file I have the username and password set with remote_user and ansible_ssh_password and if you have been keeping up with Ansible you might know remote_user is being replaced by ansible_user. So on a whim I set it to ansible_user instead, and it worked! Incredible, I've figured out the issue, made the fix permanent and I can call it a day. But... why though? I haven't touched the image since I created it six months ago. Ansible is pinned to 2.18.1 so it's not like an update has fully deprecated that option. Color me confused as hell. This shouldn't be an issue, but rule three of the debugging commandments says to "quit thinking and look," and that's what I'm gonna do. So like anyone who's gonna quit thinking, I load my local AI model. Gemma 3 12B QAT, if you're curious. It's a bit verbose and I have to poke and prod it in the right direction, which is to be expected with such a small model, but eventually it mentions something that causes the thinking to come back.

An update to a base image can propagate changes in a container which hasn't been rebuilt? Yeah, apparently it can. In hindsight this should've been fairly obvious if you know how Docker layers work, but it didn't quite click until now. If you don't know, when you build a container image it gets made in layers. Think of it like bricks, if you change the structure of the bricks on the bottom, it's going to affect the bricks above them as well.

I'm still a bit dubious at this point considering the base image I used is pinned to alpine/ansible:2.18.1 so it still shouldn't have changed, but hey I'll dig in anyway. Huh, the image on docker hub got updated two months ago. And the Alpine 3 image used by it was updated five months ago, both after I built the image initially. Holy shit, this weird little nuance could actually have caused this whole outage.

I still don't actually know if this is the root cause, but it's the best guess I have. I also don't know what exactly changed, but theoretically an update in alpine could have changed something related to SSH and now here we are. What's the takeaway from this? How could I have prevented this from happening? I mean, ideally cert automation (and any automation, really) is something you just set and forget, otherwise it kind of defeats the purpose. Well, I suppose I could have used a different docker image for Ansible and dug into the dockerfiles to see what comes from where... But let's be realistic. It all comes down to one oversight caused by my own arrogance. A while back, when I was setting up Uptime Kuma to monitor my services, I of course opted not to enable certificate expiry reminders. Why did I neglect something as important as this? Well, because I had automation for it, of course. The funny thing is, I checked the logs of that container a few days ago. No errors. So let this be a lesson to you, dear reader, if you think your automation exempts you from monitoring then you have made a mistake. Now if you'll excuse me, I need to go enable certificate expiration alerts.

[jarviscodinghub]

CMPT 353 Assignment 1 Solved

This assignment has four parts. Please submit the answers for the assignment in a single pdf file called Assignment1.pdf. Part A) 20 Points Explain the use of the following docker commands. A1) build A2) run Part B) 30 Points Write a Dockerfile that will create a docker image (tagged my/python) using the most recent python image on “docker hub”. Please make sure that port 8080 is exposed and…

[hawskstack]

Getting Started with Red Hat OpenShift Container Platform for Developers

Introduction

As organizations move toward cloud-native development, developers are expected to build applications that are scalable, reliable, and fast to deploy. Red Hat OpenShift Container Platform is designed to simplify this process. Built on Kubernetes, OpenShift provides developers with a robust platform to deploy and manage containerized applications — without getting bogged down in infrastructure details.

In this blog, we’ll explore the architecture, key terms, and how you, as a developer, can get started on OpenShift — all without writing a single line of code.

What is Red Hat OpenShift?

OpenShift is an enterprise-grade container application platform powered by Kubernetes. It offers a developer-friendly experience by integrating tools for building, deploying, and managing applications seamlessly. With built-in automation, a powerful web console, and enterprise security, developers can focus on building features rather than infrastructure.

Core Concepts and Terminology

Here are some foundational terms that every OpenShift developer should know:

Project: A workspace where all your application components live. It's similar to a folder for organizing your deployments, services, and routes.

Pod: The smallest unit in OpenShift, representing one or more containers that run together.

Service: A stable access point to reach your application, even when pods change.

Route: A way to expose your application to users outside the cluster (like publishing your app on the web).

Image: A template used to create a running container. OpenShift supports automated image builds.

BuildConfig and DeploymentConfig: These help define how your application is built and deployed using your code or existing images.

Source-to-Image (S2I): A unique feature that turns your source code into a containerized application, skipping the need to manually build Docker images.

Understanding the Architecture

OpenShift is built on several layers that work together:

Infrastructure Layer

Runs on cloud, virtual, or physical servers.

Hosts all the components and applications.

Container Orchestration Layer

Based on Kubernetes.

Manages containers, networking, scaling, and failover.

Developer Experience Layer

Includes web and command-line tools.

Offers templates, Git integration, CI/CD pipelines, and automated builds.

Security & Management Layer

Provides role-based access control.

Manages authentication, user permissions, and application security.

Setting Up the Developer Environment (No Coding Needed)

OpenShift provides several tools and interfaces designed for developers who want to deploy or test applications without writing code:

✅ Web Console Access

You can log in to the OpenShift web console through a browser. It gives you a graphical interface to create projects, deploy applications, and manage services without needing terminal commands.

✅ Developer Perspective

The OpenShift web console includes a “Developer” view, which provides:

Drag-and-drop application deployment

Built-in dashboards for health and metrics

Git repository integration to deploy applications automatically

Access to quick-start templates for common tech stacks (Java, Node.js, Python, etc.)

✅ CodeReady Containers (Local OpenShift)

For personal testing or local development, OpenShift offers a tool called CodeReady Containers, which allows you to run a minimal OpenShift cluster on your laptop — all through a simple installer and user-friendly interface.

✅ Preconfigured Templates

You can select application templates (like a basic web server, database, or app framework), fill in some settings, and OpenShift will take care of deployment.

Benefits for Developers

Here’s why OpenShift is a great fit for developers—even those with minimal infrastructure experience:

🔄 Automated Build & Deploy: Simply point to your Git repository or select a language — OpenShift will take care of the rest.

🖥 Intuitive Web Console: Visual tools replace complex command-line tasks.

🔒 Built-In Security: OpenShift follows strict security standards out of the box.

🔄 Scalability Made Simple: Applications can be scaled up or down with a few clicks.

🌐 Easy Integration with Dev Tools: Works well with CI/CD systems and IDEs like Visual Studio Code.

Conclusion

OpenShift empowers developers to build and run applications without needing to master Kubernetes internals or container scripting. With its visual tools, preconfigured templates, and secure automation, it transforms the way developers approach app delivery. Whether you’re new to containers or experienced in DevOps, OpenShift simplifies your workflow — no code required.

For more info, Kindly follow: Hawkstack Technologies

[disease1]

Best practices for running Buildah in a container https://www.altdatum.com/wp-content/uploads/2019/10/buildah-1.png https://www.altdatum.com/best-practices-for-running-buildah-in-a-container-2/?feed_id=135936&_unique_id=6868dbae9c6ea