Ubuntu 24.04 LXC Basic's - Revision history

AwesomO: /* Rename Containers */

2025-06-05T13:27:16Z

Rename Containers

← Older revision		Revision as of 13:27, 5 June 2025
Line 497:		Line 497:

	<code>lxc rename <old-container-name> <new-container-name></code>		<code>lxc rename <old-container-name> <new-container-name></code>

			==Fix Networking Problems When Using Docker with LXC==
			To resolve networking conflicts between Docker and LXC containers on Ubuntu 24.04, enable IP forwarding on the host system:
			* Open the sysctl configuration file in your preferred editor
			<code>sudo $EDITOR /etc/sysctl.conf</code>
			* Uncomment or add the following line (around line 28):
			<pre>net.ipv4.ip_forward=1</pre>
			* Apply the updated configuration to enable IP forwarding:
			<code>sysctl -p</code><br>
			* Restart the system to ensure all changes take effect.

			This should resolve the networking issue for LXC containers when Docker is installed.

	==Limit CPU and RAM per container can use==		==Limit CPU and RAM per container can use==

AwesomO: /* Clone/Copy a Snapshot */

2025-04-09T20:12:56Z

Clone/Copy a Snapshot

← Older revision		Revision as of 20:12, 9 April 2025
Line 420:		Line 420:

	The new container `newbuild1` is now a fully independent copy of the `1804build` state at the `one` snapshot, ready for builds.		The new container `newbuild1` is now a fully independent copy of the `1804build` state at the `one` snapshot, ready for builds.
			====To see snapshot names====
			* you should see which containers all ready have snapshots on the right side colume when you <code>lxc ls</code>
			* to see the snapshot names of the containers:
			<code>lxc info <container_name></code>

	===Compare the snapshots and see what has changed between them===		===Compare the snapshots and see what has changed between them===

AwesomO: /* Limit CPU and RAM per container can use */

2025-04-09T19:59:49Z

Limit CPU and RAM per container can use

← Older revision		Revision as of 19:59, 9 April 2025
Line 489:		Line 489:
	* Permissions: Ensure you have sufficient permissions to view and compare the datasets.		* Permissions: Ensure you have sufficient permissions to view and compare the datasets.
	* Efficiency: zfs diff is generally efficient but might take time depending on the size and number of changes between the snapshots.		* Efficiency: zfs diff is generally efficient but might take time depending on the size and number of changes between the snapshots.

			==Rename Containers==

			<code>lxc rename <old-container-name> <new-container-name></code>

	==Limit CPU and RAM per container can use==		==Limit CPU and RAM per container can use==

AwesomO: /* Limit CPU and RAM per container can use */

2025-04-09T19:58:53Z

Limit CPU and RAM per container can use

← Older revision		Revision as of 19:58, 9 April 2025
Line 491:		Line 491:

	==Limit CPU and RAM per container can use==		==Limit CPU and RAM per container can use==
			<!--
			NOT TESTED clearly flaws
	In Ubuntu 24.04, you can limit the CPU and RAM usage of an LXC (Linux Containers) container using the built-in resource control features provided by LXC.		In Ubuntu 24.04, you can limit the CPU and RAM usage of an LXC (Linux Containers) container using the built-in resource control features provided by LXC.

Line 550:		Line 552:
	lxc-start -n <container-name>		lxc-start -n <container-name>
	</pre>		</pre>
			-->

	== References ==		== References ==

AwesomO: /* Running Commands from Host on Container */

2025-04-05T19:53:10Z

Running Commands from Host on Container

@@ Line 235: / Line 235: @@
 ssh ubuntu@<container_ip>
 </code>
 == Running Commands from Host on Container ==

AwesomO: /* Compare the snapshots and see what has changed between them */

2025-04-02T09:44:29Z

Compare the snapshots and see what has changed between them

← Older revision		Revision as of 09:44, 2 April 2025
Line 364:		Line 364:

	This creates a compressed tarball of the snapshot that you can store elsewhere.		This creates a compressed tarball of the snapshot that you can store elsewhere.

			===Clone/Copy a Snapshot===

			This section describes how to create an Ubuntu 18.04 build container using LXD, install dependencies, snapshot it, and clone the snapshot into a new container.

			* Create the Build Container
			Launch an Ubuntu 18.04 container named `1804build`: <br>
			<code>lxc launch ubuntu:18.04 1804build</code>

			* Install Dependencies
			Access the container and install required packages: <br>
			<code>lxc exec 1804build bash</code> <br>
			Inside, run: <br>
			<code>apt update && apt install build-essential</code> <br>
			Install all other packages and exit when done.

			* Stop the Container to prepare for snapshotting
			<code>lxc stop 1804build</code>

			* Create a Snapshot named `one`
			<code>lxc snapshot 1804build one</code>

			* Clone the Snapshot - Copy the snapshot `one` to a new container called `newbuild1`
			<code>lxc copy 1804build/one newbuild1</code>

			* Start and Verify
			Start the new container: <br>
			<code>lxc start newbuild1</code>
			Check it’s running and has the dependencies: <br>
			<code>lxc exec newbuild1 bash</code>

			The new container `newbuild1` is now a fully independent copy of the `1804build` state at the `one` snapshot, ready for builds.

	===Compare the snapshots and see what has changed between them===		===Compare the snapshots and see what has changed between them===

AwesomO: Created page with "= Quick Start Guide: Ubuntu LXC Containers for CompleteNoobs = NOTES - lost all notes on localwiki when i did bad backup before nuke and pave, starting again. == Introduction == This guide will help you get started with LXC (Linux Containers) on Ubuntu. We'll cover how to login to a container, run commands from the host on the container, and move files between the host and container. == Prerequisites == * Ubuntu system with LXC installed * Basic knowledge of terminal..."

2025-02-17T08:20:38Z

Created page with "= Quick Start Guide: Ubuntu LXC Containers for CompleteNoobs = NOTES - lost all notes on localwiki when i did bad backup before nuke and pave, starting again. == Introduction == This guide will help you get started with LXC (Linux Containers) on Ubuntu. We'll cover how to login to a container, run commands from the host on the container, and move files between the host and container. == Prerequisites == * Ubuntu system with LXC installed * Basic knowledge of terminal..."

New page

= Quick Start Guide: Ubuntu LXC Containers for CompleteNoobs =

NOTES - lost all notes on localwiki when i did bad backup before nuke and pave, starting again.

== Introduction ==
This guide will help you get started with LXC (Linux Containers) on Ubuntu. We'll cover how to login to a container, run commands from the host on the container, and move files between the host and container.

== Prerequisites ==
* Ubuntu system with LXC installed
* Basic knowledge of terminal commands

==Installing LXD==

lxd comes preinstalled with ubuntu 24.04

* check current version
<code>sudo lxd --version</code><br>
Output:
<pre>
root@lxd-test:~# lxd --version
5.21.2 LTS
</pre>

* update snap package info
<code>sudo snap refresh --list</code>

* check if updated version avalible.
<code>snap search</code> <br>
<pre>
root@lxd-test:~# snap search lxd
Name Version Publisher Notes Summary
lxd 5.21.2-34459c8 canonical✓ - LXD - container and VM manager
lxd-bgp 0+git.a39f061 stgraber - BGP server that exposes LXD routes
lxd-demo-server 0+git.6d54658 tomparrott - Online software demo sessions using LXD
lxd-imagebuilder git-22d1484 tomparrott classic System container and VM image builder for LXD
lxdmosaic 0+git.c6f53f3f turtle0x1 - A web interface to manage multiple instances of LXD
lxd-gitlab-runner 0.1 alexclewontin - GitLab CI/CD runner with built in LXD executor
microcloud 1.1-04a1c49 canonical✓ - Automated small-scale cloud deployment
prometheus-juju-exporter 3.1.0 canonical✓ - Prometheus exporter for Juju machine statuses
ghvmctl 0.4.1 snapcrafters✪ - A utility for manipulating virtual machines during snap testing.
fabrica 1.1.0 ogra - Build snaps by simply pointing a web form to a git tree
pluto 0.1.0 nuccitheboss - A swiss-army knife for managing HPC clusters built with Ubuntu
hon-lxd-toolbox 0.7.40.21-b h350730 - Swiss knife of shell tools
distrobuilder 3.0 stgraber classic Image builder for LXC and LXD
satellite 0.1.2 alanzanattadev - Advanced scalable Open source intelligence platform
</pre>

All upto date already, but if was not then

* update lxd
<code>sudo snap refresh lxd</code>

* check version is
<code>snap info lxd</code><br>
<code>lxd --version</code>

<div class="toccolours mw-collapsible mw-collapsed">
Upgrading to Specific Channels (Optional):
<div class="mw-collapsible-content">

LXD can be upgraded to specific versions or channels. This allows you to choose between stability and newer features. The available channels are:

* '''latest/stable''': The most stable release, recommended for production environments
* '''latest/candidate''': Release candidates, for testing before they become stable
* '''latest/beta''': Beta versions, may contain bugs but offer newer features
* '''latest/edge''': The most recent updates, potentially unstable

To upgrade LXD to a specific channel, use the following command:

<syntaxhighlight lang="bash">
sudo snap refresh lxd --channel=CHANNEL_NAME
</syntaxhighlight>

For example, to upgrade to the stable channel:

<syntaxhighlight lang="bash">
sudo snap refresh lxd --channel=latest/stable
</syntaxhighlight>

Or, to switch to the candidate channel:

<syntaxhighlight lang="bash">
sudo snap refresh lxd --channel=latest/candidate
</syntaxhighlight>

* Restarting LXD After Updates (Optional)

After upgrading LXD, it's sometimes necessary to restart the LXD daemon to apply changes. You can do this with the following command:

<syntaxhighlight lang="bash">
sudo systemctl restart snap.lxd.daemon
</syntaxhighlight>

This ensures that LXD is running the most recently installed version.

</div>
</div>

==Add user to the lxc group==

=== Adding a User to the LXC Group ===
To manage LXC containers without using `sudo`, add your user to the `lxd` group.

Add the user to the `lxd` group:

<code>sudo adduser $USER lxd</code>

====Check user in group Using <b>id</b> Command====
You can use the <b>id</b> command, which shows the user's identity and associated groups:

<code>
id $USER
</code>

This will display something like:
<pre>
uid=1000(username) gid=1000(username) groups=1000(username),4(adm),27(sudo),109(lxd)
</pre>
Here, 109(lxd) indicates that the user is part of the lxd group.

==LXD Initialization==

Its pretty straight forward:<br>
<code>sudo lxd init</code>

* [[Ubuntu_24.04_-_LXD_Initialization | If you want a LXD Initialization Guide click this link]]

==Launching First container==

<code>lxc launch ubuntu:18.04 cnoobs</code><br>

* IF you see:
<pre>
lxc launch ubuntu:18.04 cnoobs
Error: LXD unix socket "/var/snap/lxd/common/lxd/unix.socket" not accessible: permission denied
</pre>
* REBOOT to apply changes
* OR logout and backin to apply changes
<div class="toccolours mw-collapsible mw-collapsed">
a way to apply group changes without logging out and back in - tip
<div class="mw-collapsible-content">
On Ubuntu 24.04 using Bash, you can use the newgrp command. Here's how you can do it:

* First, add your user to the lxd group:

<pre>
sudo adduser $USER lxd
</pre>

Then, to apply the changes immediately without logging out, use:

<pre>
newgrp lxd
</pre>

The newgrp command starts a new shell session with the updated group membership. This allows you to immediately use the permissions granted by the new group without logging out and back in. Alternatively, you can also use:

<pre>
exec sudo su -l $USER
</pre>

This command will replace your current shell with a new login shell for your user, which will have the updated group memberships. Both of these methods will apply the group changes immediately, allowing you to use LXD commands without having to log out and back in. Remember, these changes only apply to the current terminal session. If you open a new terminal window, you might need to run the command again or log out and back in for the changes to take effect system-wide.
</div>
</div>

* '''syntax''' <code><command> <image> <container_name></code>

<div class="toccolours mw-collapsible mw-collapsed">
<code>lxc launch ubuntu:18.04 cnoobs</code> - explained
<div class="mw-collapsible-content">
To create and start your first LXC container, use the following command:

<code>lxc launch ubuntu:18.04 cnoobs</code>

This command does the following:
* '''lxc launch''': Tells LXD to create and start a new container
* '''ubuntu:18.04''': Specifies the image to use (Ubuntu 18.04 in this case)
* '''cnoobs''': This is the name you're giving to your new container

After running this command, LXD will download the Ubuntu 18.04 image (if it hasn't already) and create a new container named "cnoobs" based on this image.

To see other available images, you can use:

<code>lxc image list images:</code>

This will show a list of available images from the default remote. You can also specify different versions or distributions, for example:

* <code>lxc launch ubuntu:20.04 mycontainer</code> for Ubuntu 20.04
* <code>lxc launch debian:10 mydebian</code> for Debian 10
* <code>lxc launch centos:8 mycentos</code> for CentOS 8

To get more detailed information about available images, use:

<code>lxc image list images: | grep -i ubuntu</code>

Replace "ubuntu" with any other distribution name to see its available versions.

Remember, the container name (like "cnoobs" in the example) must be unique within your LXD installation.
</div>
</div>

== Logging into the Container ==

=== Method 1: Using lxc exec ===
To log into the container directly:

<code>
lxc exec cnoobs -- bash
</code>

This command gives you a bash shell inside the container.

=== Method 2: Using SSH ===
If you prefer using SSH:

1. Install SSH in the container:
<code>
lxc exec cnoobs -- apt update
lxc exec cnoobs -- apt install openssh-server -y
</code>

2. Set a password for the ubuntu user:
<code>
lxc exec cnoobs -- passwd ubuntu
</code>

3. Get the container's IP address:
<code>
lxc list cnoobs
</code>

4. SSH into the container:
<code>
ssh ubuntu@<container_ip>
</code>

== Running Commands from Host on Container ==
To run a command in the container from the host system, use:

<code>
lxc exec cnoobs -- <command>
</code>

For example, to list files in the container's home directory:

<code>
lxc exec cnoobs -- ls /home/ubuntu
</code>

== Moving Files and Directories ==
=== From Host to Container ===
Use the `lxc file push` command:

<code>
lxc file push /path/on/host/file.txt cnoobs/path/in/container/
</code>

For example, to copy a file to the ubuntu user's home directory:

<code>
lxc file push ~/myfile.txt cnoobs/home/ubuntu/
</code>

=== From Container to Host ===
Use the `lxc file pull` command:

<code>
lxc file pull cnoobs/path/in/container/file.txt /path/on/host/
</code>

For example, to copy a file from the container's home directory to the host's current directory:

<code>
lxc file pull cnoobs/home/ubuntu/myfile.txt ./
</code>

=== Moving Directories ===
To move entire directories, add the -r (recursive) flag:

<pre>
lxc file push -r ~/mydir cnoobs/home/ubuntu/
lxc file pull -r cnoobs/home/ubuntu/mydir ./
</pre>

==Snapshot and restore containers==

===If ZFS as the underlying storage driver===

====Snapshot a Container====
To create a snapshot of a container, use the following command:
<code>
lxc snapshot <container_name> <snapshot_name>
</code>

* <container_name>: Replace this with the name of the container you want to snapshot.
* <snapshot_name>: Replace this with a descriptive name for the snapshot.

<b>Example:</b>

<code>
lxc snapshot cnoobs snapshot1
</code>

This command creates a snapshot named snapshot1 of the container cnoobs.

====List Snapshots====
To view the snapshots for a specific container, you can use:

<code>
lxc info <container_name>
</code>

or more specifically for snapshots:

<code>
lxc snapshot list <container_name>
</code>

====Restore a Snapshot====
If you need to restore a container to a previous state using a snapshot, use the following command:

<code>
lxc restore <container_name> <snapshot_name>
</code>
* <container_name>: The name of the container you want to restore.
* <snapshot_name>: The name of the snapshot to which you want to revert.
Example:

<code>
lxc restore cnoobs snapshot1
</code>
This command will revert the container cnoobs to the state it was in when the snapshot1 snapshot was taken.

====Delete a Snapshot====
Once you no longer need a snapshot, you can delete it to free up space:

<code>
lxc delete <container_name>/<snapshot_name>
</code>
Example:

<code>
lxc delete cnoobs/snapshot1
</code>

This command deletes the snapshot1 snapshot of the cnoobs container.

====Backing Up a Snapshot====

If you want to create a backup of the snapshot outside of LXD (for example, to transfer to another system), you can export it:

<code>
lxc export <container_name> --instance-only --snapshot <snapshot_name> <output_file.tar.gz>
</code>

Example:

<code>
lxc export mycontainer --instance-only --snapshot snapshot1 mycontainer-snapshot1.tar.gz
</code>

This creates a compressed tarball of the snapshot that you can store elsewhere.

===Compare the snapshots and see what has changed between them===

====On host <b>zfsutils-linux</b> required====

<code>sudo apt install zfsutils-linux</code>

====Get the ZFS Dataset Names for the Snapshots====
LXD snapshots are stored as ZFS datasets. First, you need to identify the ZFS dataset names associated with your LXD container snapshots.

<code>
zfs list -t snapshot | grep <container_name>
</code>

This will list all ZFS snapshots related to your container.

==== Diff the Snapshots Using ZFS ====
Once you have the snapshot names, you can use zfs diff to see the differences between two snapshots. The zfs diff command shows changes such as file creations, deletions, and modifications between two snapshots.

<code>
zfs diff <snapshot1> <snapshot2>
</code>

Example Workflow

Let's assume your container is named mycontainer, and you have two snapshots snapshot1 and snapshot2. Here's how you would do it:

* List the ZFS Snapshots:

<code>
zfs list -t snapshot | grep mycontainer
</code>

You might see output like this:

<pre>
tank/containers/mycontainer@snapshot1
tank/containers/mycontainer@snapshot2
</pre>

Diff the Snapshots:

<code>
zfs diff tank/containers/mycontainer@snapshot1 tank/containers/mycontainer@snapshot2
</code>

This command will output the differences between the two snapshots. The output might look like this:

<pre>
M /path/to/modified/file
- /path/to/deleted/file
+ /path/to/added/file
R /path/to/renamed/file -> /path/to/newname/file
M: Modified files
-: Deleted files
+: Added files
R: Renamed files
</pre>

====Interpreting the Output====

The output will show you which files have been added, removed, or modified between the two snapshots.
If you're comparing entire directories or larger datasets, this can give you a quick overview of what's changed.

Notes:

* ZFS Tools Required: The zfs diff command is a ZFS feature, so you need to have ZFS installed and configured.
* Permissions: Ensure you have sufficient permissions to view and compare the datasets.
* Efficiency: zfs diff is generally efficient but might take time depending on the size and number of changes between the snapshots.

==Limit CPU and RAM per container can use==
In Ubuntu 24.04, you can limit the CPU and RAM usage of an LXC (Linux Containers) container using the built-in resource control features provided by LXC.

===Limiting CPU Usage===
You can limit the CPU usage of an LXC container in two ways: by specifying the number of CPU cores the container can use, and by setting a CPU usage limit as a percentage of the host's total CPU resources.

* Limit CPU Cores:
You can assign specific CPU cores to a container by editing the container's configuration file.

<code>lxc-cgroup -n <container-name> cpuset.cpus <cpu-cores></code>

For example, to assign CPU cores 0 and 1 to a container:

<code>lxc-cgroup -n my-container cpuset.cpus 0,1</code>

Alternatively, you can add the following line to the container’s configuration file (usually found in /var/lib/lxc/<container-name>/config):

<code>lxc.cgroup.cpuset.cpus = 0,1</code>

* Limit CPU Usage
You can limit the CPU usage as a percentage of the host’s total CPU time.

<code>lxc-cgroup -n <container-name> cpu.shares <value></code>

For example, to limit the CPU usage to 20%:

<code>lxc.cgroup.cpu.shares = 204</code>

This value is relative to the CPU shares of other containers. The default value is 1024, so 204 is about 20% of one CPU.

=== Limiting RAM Usage ===
You can also limit the amount of RAM a container can use.

* Limit Memory:
To set a hard limit on the maximum amount of RAM a container can use, add the following line to the container’s configuration file:

<code>lxc.cgroup.memory.limit_in_bytes = 512M</code>

This example limits the container to 512 MB of RAM.

* Limit Swap Usage:
You can also limit the amount of swap memory a container can use:

<code>lxc.cgroup.memory.memsw.limit_in_bytes = 1G</code>

This example limits the total memory usage (RAM + swap) to 1 GB.

=== Applying the Changes ===
After editing the configuration file, restart the container to apply the changes:

<pre>
lxc-stop -n <container-name>
lxc-start -n <container-name>
</pre>

== References ==
* [https://linuxcontainers.org/lxc/introduction/ LXC Introduction]
* [https://ubuntu.com/server/docs/containers-lxc Ubuntu LXC Documentation]

This wiki-formatted tutorial provides a quick start guide for CompleteNoobs to work with LXC containers on Ubuntu. It covers the basics of logging in, running commands, and moving files, which are essential operations for beginners working with containers.