document/TranslateProject
2
0
Fork 0
mirror of https://github.com/LCTT/TranslateProject.git synced 2025-02-25 00:50:15 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #39 from LCTT/master

Browse Source 
sync
This commit is contained in:
SamMa 2022-05-25 09:33:21 +08:00 committed by GitHub
commit 4a0aa181bf
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 974 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
sources/news/20220523 Linux Kernel 5.18 Released with Graphics Driver Changes and New Hardware Support.md
View File

@ -2,7 +2,7 @@
[#]: via: "https://news.itsfoss.com/linux-kernel-5-18-release/"
[#]: author: "Ankush Das https://news.itsfoss.com/author/ankush/"
[#]: collector: "lkxed"
[#]: translator: " "
[#]: translator: "PeterPan0106"
[#]: reviewer: " "
[#]: publisher: " "
[#]: url: " "
@ -105,7 +105,7 @@ via: https://news.itsfoss.com/linux-kernel-5-18-release/
作者：[Ankush Das][a]
选题：[lkxed][b]
译者：[译者ID](https://github.com/译者ID)
译者：[PeterPan0106](https://github.com/PeterPan0106)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出

60
sources/news/20220524 Woah! Broadcom Could Acquire VMware for $60 Billion.md Normal file
View File

@ -0,0 +1,60 @@
[#]: subject: "Woah! Broadcom Could Acquire VMware for $60 Billion"
[#]: via: "https://news.itsfoss.com/broadcom-vmware-deal/"
[#]: author: "Ankush Das https://news.itsfoss.com/author/ankush/"
[#]: collector: "lkxed"
[#]: translator: " "
[#]: reviewer: " "
[#]: publisher: " "
[#]: url: " "
Woah! Broadcom Could Acquire VMware for $60 Billion
======
Broadcom’s interested to acquire VMware for $60 billion, making it one of the biggest tech deals in 2022.
![broadcom][1]
Broadcom, a semiconductor chip company, is infamous among desktop Linux users for the incompatibility issues with its wireless adapter/card and drivers.
And, it is now planning to get into the cloud computing market by acquiring one of the biggest players in the industry, i.e., **VMware**.
VMware is not an open-source company, but it offers some open-source tools and Linux support for its virtualization software.
In this case, **The Wall Street Journal** [reports][2] that Broadcom and VMware can potentially announce this acquisition later this week on Thursday.
### Broadcom to Enter the Cloud Computing Market
[Broadcom][3] should be a familiar name to Linux users when we talk about wireless network chips and their drivers.
And, with the $60 billion deal for [VMware][4], they could expand their take on the industry through VMware’s reach in the cloud computing sector.
So, their decision also influences the talk about the acquisition by Broadcom.
Hence, it is safe to say that the deal may or may not go through if the discussions fall apart.
And, for the payment to succeed, the report also mentions that Broadcom plans to take help of banks for a $40 billion debt package.
Considering that the report mentions the final price is still up for discussion, the $60 billion value can change (but something around it).
### Wrapping Up
You can keep an eye on VMware’s shares and Broadcom Inc if you are someone who is interested in getting involved in the market.
What do you think about Broadcom acquiring VMware? Do you think it’s going to go through with Dell involved with a major stake in the company? Feel free to share your thoughts in the comments below.
--------------------------------------------------------------------------------
via: https://news.itsfoss.com/broadcom-vmware-deal/
作者：[Ankush Das][a]
选题：[lkxed][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://news.itsfoss.com/author/ankush/
[b]: https://github.com/lkxed
[1]: https://news.itsfoss.com/wp-content/uploads/2022/05/broadcom-vmware-acquisition.jpg
[2]: https://www.wsj.com/articles/broadcom-discussing-paying-around-140-a-share-for-vmware-people-say-11653334946
[3]: https://www.broadcom.com/
[4]: https://www.vmware.com/i

132
sources/tech/20220520 Customize GNOME 42 with A Polished Look.md
View File

@ -1,132 +0,0 @@
[#]: subject: "Customize GNOME 42 with A Polished Look"
[#]: via: "https://www.debugpoint.com/2022/05/customize-gnome-42-look-1/"
[#]: author: "Arindam https://www.debugpoint.com/author/admin1/"
[#]: collector: "lkxed"
[#]: translator: "geekpi"
[#]: reviewer: " "
[#]: publisher: " "
[#]: url: " "
Customize GNOME 42 with A Polished Look
======
A tutorial on how you can give your favourite GNOME desktop a polished look, in 5 minutes.
There are many ways you can customize your favourite GNOME desktop with icons, themes, cursors and wallpapers. This article shows you how to give the GNOME 42 desktop a more polished look. The GNOME 42 desktop environment is available with the recently released Ubuntu 22.04 LTS and Fedora 36.
Before you read further, here’s how it looks with a side by side comparison (before and after).
![GNOME before customisation][1]
![GNOME after customisation][2]
I am going to divide this tutorial into two sections.
The first section deals with setting up and installing required packages. And second, how to apply various settings to get your desired look.
This tutorial was mainly tested on Ubuntu 22.04 LTS. However, it should work in other variants of Ubuntu and Fedora.
### Customize GNOME 42 with a Polished Look
#### Setup
* First, enable your system for Flatpak because we need to install the Extension Manager to download some required GNOME Shell extensions for this tutorial.
* So, to do that, open up a terminal and run the following commands.
```
sudo apt install flatpak gnome-software-plugin-flatpakflatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
```
* Reboot the computer once done.
* Then run the following command from the terminal to install the Extensions Manager app to download GNOME Shell Extensions.
```
flatpak install flathub com.mattjakeman.ExtensionManager
```
* Open the Extension Manager application and install two extensions. The first one is Floating Dock which features a super cool dock which you can move around anywhere on your desktop. Second, install the User themes extensions to help you install the external GTK themes in your Ubuntu Linux.
![User Themes Extension][3]
![Floating Dock Extension][4]
* Secondly, install the [Materia Theme][5] using the below commands. You have to build it as it doesn’t have any executable. Run the following commands in sequence in Ubuntu to install.
```
git clone https://github.com/ckissane/materia-theme-transparent.gitcd materia-theme-transparentmeson _buildmeson install -C _build
```
* Additionally, download the [Kora Icon theme][6] from the below link. After downloading, extract the files and copy the below four folders to `/home/<user name>/.icons` path. Create the .icons folder if it is not present.
[Download Kora Icon Theme][7]
![Kora Icon Theme][8]
* Besides the above changes, download the awesome Bibata cursor theme from the below link. After download, extract and copy the folders to the same `/home/<user name>/.icons` folder.
[Download Bibata Cursor Theme][9]
* In addition to the above, if you want a nice font which goes with the above themes, [download Robot font][10] from Google Fonts and copy them to `/home/<user name>/.fonts` folder.
* Finally, restart your system once again.
#### Configuration
* Open the Extension Manager, enable the Floating Dock and User Themes, and disable the Ubuntu Dock.
![Changes to Extensions][11]
* In addition, open the Floating dock settings and make the following changes.
![Floating Dock Settings][12]
* Furthermore, open the [GNOME Tweak Tool][13], and go to the Appearance tab. Set the followings.Cursor: Bibata-Original-IceShell Theme: MateriaIcon: Kora
* Cursor: Bibata-Original-Ice
* Shell Theme: Materia
* Icon: Kora
* Cursor: Bibata-Original-Ice
* Shell Theme: Materia
* Icon: Kora
* Other than that, you may also want to change the font. To do that, go to the Fonts tab and change the document and interface to Robot 10pt.
* Alternatively, you can also change the accent colour and style from Settings which comes by default with Ubuntu 22.04.
* Finally, download a nice wallpaper as per your preference. For this tutorial, I have downloaded a sample wallpaper from [here][14].
* If all goes well, you should have a nice desktop, as shown below.
![Customize GNOME 42 – Final Look][15]
Enjoy a polished GNOME 42. Cheers.
--------------------------------------------------------------------------------
via: https://www.debugpoint.com/2022/05/customize-gnome-42-look-1/
作者：[Arindam][a]
选题：[lkxed][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://www.debugpoint.com/author/admin1/
[b]: https://github.com/lkxed
[1]: https://i2.wp.com/www.debugpoint.com/wp-content/uploads/2022/05/GNOME-before-customisation.jpg?ssl=1
[2]: https://i0.wp.com/www.debugpoint.com/wp-content/uploads/2022/05/GNOME-after-customisation.jpg?ssl=1
[3]: https://www.debugpoint.com/wp-content/uploads/2022/05/User-Themes-Extension2.jpg
[4]: https://www.debugpoint.com/wp-content/uploads/2022/05/Floating-Doc-Extension.jpg
[5]: https://github.com/ckissane/materia-theme-transparent
[6]: https://github.com/bikass/kora/
[7]: https://github.com/bikass/kora/archive/refs/heads/master.zip
[8]: https://www.debugpoint.com/wp-content/uploads/2022/05/Kora-Icon-Theme.jpg
[9]: https://www.pling.com/p/1197198/
[10]: https://fonts.google.com/specimen/Roboto
[11]: https://www.debugpoint.com/wp-content/uploads/2022/05/Changes-to-Extensions.jpg
[12]: https://www.debugpoint.com/wp-content/uploads/2022/05/Floating-Dock-Settings.jpg
[13]: https://www.debugpoint.com/2018/05/customize-your-ubuntu-desktop-using-gnome-tweak/
[14]: https://www.pexels.com/photo/colorful-blurred-image-6985048/
[15]: https://www.debugpoint.com/wp-content/uploads/2022/05/Customize-GNOME-42-Final-Look.jpg

187
sources/tech/20220524 12 essential Linux commands for beginners.md Normal file
View File

@ -0,0 +1,187 @@
[#]: subject: "12 essential Linux commands for beginners"
[#]: via: "https://opensource.com/article/22/5/essential-linux-commands"
[#]: author: "Don Watkins https://opensource.com/users/don-watkins"
[#]: collector: "lkxed"
[#]: translator: " "
[#]: reviewer: " "
[#]: publisher: " "
[#]: url: " "
12 essential Linux commands for beginners
======
I recommend these commands to anyone who is getting started with Linux.
![Command line prompt][1]
Image by: Opensource.com
When operating on the Linux command line, it is easy to get disoriented, which can have disastrous consequences. I once issued a remove command before realizing that I'd moved the boot directory of my computer. I learned to use the `pwd` command to know exactly which part of the file system I was in (and these days, there are command projects, like [trashy and trash-cli][2], that serve as intermediates when removing files).
When I was new to Linux, I had a cheat sheet that hung over my desk to help me remember those commands as I managed my Linux servers. It was called the *101 commands for Linux* cheat sheet. As I became more familiar with these commands, I became more proficient with server administration.
Here are 12 Linux commands I find most useful.
### 1. Print working directory (pwd)
The `pwd` command prints your working directory. In other words, it outputs the path of the directory you are currently working in. There are two options: `--logical` to display your location with any symlinks and `--physical` to display your location after resolving any symlinks.
### 2. Make directory (mkdir)
Making directories is easy with the `mkdir` command. The following command creates a directory called `example` unless `example` already exists:
```
$ mkdir example
```
You can make directories within directories:
```
$ mkdir -p example/one/two
```
If directories `example` and `one` already exist, only directory `two` is created. If none of them exist, then three nested directories are created.
### 3. List (ls)
Coming from MS-DOS, I was used to listing files with the `dir` command. I don't recall working on Linux at the time, although today, `dir` is in the GNU Core Utilities package. Most people use the `ls` command to display the files, along with all their properties, are in a directory. The `ls` command has many options, including `-l` to view a long listing of files, displaying the file owner and permissions.
### 4. Change directory (cd)
It is often necessary to change directories. That's the `cd` command's function. For instance, this example takes you from your home directory into the `Documents` directory:
```
$ cd Documents
```
You can quickly change to your home directory with `cd ~` or just `cd` on most systems. You can use `cd ..` to move up a level.
### 5. Remove a file (rm)
Removing files is inherently dangerous. Traditionally, the Linux terminal has no Trash or Bin like the desktop does, so many terminal users have the bad habit of permanently removing data they believe they no longer need. There's no "un-remove" command, though, so this habit can be problematic should you accidentally delete a directory containing important data.
A Linux system provides `rm` and `shred` for data removal. To delete file `example.txt`, type the following:
```
$ rm example.txt
```
However, it's much safer to install a trash command, such as [trashy][3] or [trash-cli][4]. Then you can send files to a staging area before deleting them forever:
```
$ trash example.txt
```
### 6. Copy a file (cp)
Copy files with the `cp` command. The syntax is copy *from-here* *to-there*. Here's an example:
```
$ cp file1.txt newfile1.txt
```
You can copy entire directories, too:
```
$ cp -r dir1 newdirectory
```
### 7. Move and rename a file (mv)
Renaming and moving a file is functionally the same process. When you move a file, you take a file from one directory and put it into a new one. When renaming a file, you take a file from one directory and put it back into the same directory or a different directory, but with a new name. Either way, you use the `mv` command:
```
$ mv file1.txt file_001.txt
```
### 8. Create an empty file (touch)
Easily create an empty file with the `touch` command:
```
$ touch one.txt
$ touch two.txt
$ touch three.md
```
### 9. Change permissions (chmod)
Change the permissions of a file with the `chmod` command. One of the most common uses of `chmod` is making a file executable:
```
$ chmod +x myfile
```
This example is how you give a file permission to be executed as a command. This is particularly handy for scripts. Try this simple exercise:
```
$ echo 'echo Hello $USER' > hello.sh
$ chmod +x hello.sh
$ ./hello.sh
Hello, Don
```
### 10. Escalate privileges (sudo)
While administering your system, it may be necessary to act as the super user (also called root). This is where the `sudo` (or *super user do*) command comes in. Assuming you're trying to do something that your computer alerts you that only an administrator (or root) user can do, just preface it with the command `sudo` :
```
$ touch /etc/os-release && echo "Success"
touch: cannot touch '/etc/os-release': Permission denied
$ sudo touch /etc/os-release && echo "Success"
Success
```
### 11. Shut down (poweroff)
The `poweroff` command does exactly what it sounds like: it powers your computer down. It requires `sudo` to succeed.
There are actually many ways to shut down your computer and some variations on the process. For instance, the `shutdown` command allows you to power down your computer after an arbitrary amount of time, such as 60 seconds:
```
$ sudo shutdown -h 60
```
Or immediately:
```
$ sudo shutdown -h now
```
You can also restart your computer with `sudo shutdown -r now` or just `reboot`.
### 12. Read the manual (man)
The `man` command could be the most important command of all. It gets you to the documentation for each of the commands on your Linux system. For instance, to read more about `mkdir` :
```
$ man mkdir
```
A related command is `info`, which provides a different set of manuals (as long as they're available) usually written more verbosely than the often terse man pages.
### What's your favorite Linux command?
There are many more commands on a Linux system—hundreds! What's your favorite command, the one you find yourself using time and time again?
--------------------------------------------------------------------------------
via: https://opensource.com/article/22/5/essential-linux-commands
作者：[Don Watkins][a]
选题：[lkxed][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/don-watkins
[b]: https://github.com/lkxed
[1]: https://opensource.com/sites/default/files/lead-images/command_line_prompt.png
[2]: https://www.redhat.com/sysadmin/recover-file-deletion-linux
[3]: https://gitlab.com/trashy/trashy
[4]: https://github.com/andreafrancia/trash-cli

232
sources/tech/20220524 Build a Quarkus reactive application using Kubernetes Secrets.md Normal file
View File

@ -0,0 +1,232 @@
[#]: subject: "Build a Quarkus reactive application using Kubernetes Secrets"
[#]: via: "https://opensource.com/article/22/5/quarkus-kubernetes-secrets"
[#]: author: "Daniel Oh https://opensource.com/users/daniel-oh"
[#]: collector: "lkxed"
[#]: translator: " "
[#]: reviewer: " "
[#]: publisher: " "
[#]: url: " "
Build a Quarkus reactive application using Kubernetes Secrets
======
Follow security policies while developing applications for the cloud by using Kubernetes Secrets.
![Improve your DevOps security game with Ansible Vault][1]
Image by: Opensource.com
Many organizations have security policies in place that dictate how to store sensitive information. When you're developing applications for the cloud, you're probably expected to follow those policies, and to do that you often have to externalize your data storage. Kubernetes has a built-in system to access external secrets, and learning to use that is key to a safe cloud-native app.
In this article, I'm going to demonstrate how to build a Quarkus reactive application with externalized sensitive information—for instance, a password or token—using [Kubernetes Secrets][2]. A secret is a good example of how cloud platforms can secure applications by removing sensitive data from your static code. Note that you can find a solution to this tutorial [in this GitHub repository][3].
### 1. Scaffold a new reactive Quarkus project
Use the Quarkus command-line interface (CLI) to scaffold a new project. If you haven't already installed the Quarkus CLI, follow these [instructions][5] according to your operating system.
Run the following Quarkus CLI in your project directory to add `kubernetes-config`, `resteasy-reactive`, and `openshift` extensions:
```
$ quarkus create app quarkus-secret-example \
-x resteasy-reactive,kubernetes-config,openshift
```
The output should look like this:
```
Looking for the newly published extensions in registry.quarkus.io
selected extensions:
- io.quarkus:quarkus-kubernetes-config
- io.quarkus:quarkus-resteasy-reactive
- io.quarkus:quarkus-openshift
applying codestarts...
📚  java
🔨  maven
📦  quarkus
📝  config-properties
🔧  dockerfiles
🔧  maven-wrapper
🚀  resteasy-reactive-codestart
-----------
[SUCCESS] ✅  quarkus project has been successfully generated in:
--> /tmp/quarkus-secret-example
-----------
Navigate into this directory and get started: quarkus dev
```
### 2. Create a Secret in Kubernetes
To manage the Kubernetes Secrets, you have three options:
* Using kubectl
* Using Configuration File
* Node [Kustomize][6]
Use the `kubectl` command to create a new database credential (a username and password). Run the following command:
```
$ kubectl create secret generic db-credentials \                                                                      
 --from-literal=username=admin \
 --from-literal=password=secret
```
If you haven't already installed a Kubernetes cluster locally, or you have no remote cluster, you can sign in to the [developer sandbox][7], a no-cost sandbox environment for Red Hat OpenShift and CodeReady Workspaces.
You can confirm that the Secret is created properly by using the following command:
```
$ kubectl get secret/db-credentials -o yaml
```
The output should look like this:
```
apiVersion: v1
data:
  password: c2VjcmV0
  username: YWRtaW4=
kind: Secret
metadata:
  creationTimestamp: "2022-05-02T13:46:18Z"
  name: db-credentials
  namespace: doh-dev
  resourceVersion: "1190920736"
  uid: 936abd44-1097-4c1f-a9d8-8008a01c0add
type: Opaque
```
The username and password are encoded by default.
### 3. Create a new RESTful API to access the Secret
Now you can add a new RESTful (for Representational State Transfer) API to print out the username and password stored in the Kubernetes Secret. Quarkus enables developers to refer to the secret as a normal configuration using a `@ConfigureProperty` annotation.
Open a `GreetingResource.java` file in `src/main/java/org/acme`. Then, add the following method and configurations:
```
@ConfigProperty(name = "username")
    String username;
    @ConfigProperty(name = "password")
    String password;
    @GET
    @Produces(MediaType.TEXT_PLAIN)
    @Path("/securty")
    public Map securty() {
        HashMap<String, String> map = new HashMap<>();
        map.put("db.username", username);
        map.put("db.password", password);
        return map;
    }
```
Save the file.
### 4. Set the configurations for Kubernetes deployment
Open the `application.properties` file in the `src/main/resources` directory. Add the following configuration for the Kubernetes deployment. In the tutorial, I'll demonstrate using the developer sandbox, so the configurations tie to the OpenShift cluster.
If you want to deploy it to the Kubernetes cluster, you can package the application via Docker container directly. Then, you need to push the container image to an external container registry (for example, Docker Hub, quay.io, or Google container registry).
```
# Kubernetes Deployment
quarkus.kubernetes.deploy=true
quarkus.kubernetes.deployment-target=openshift
openshift.expose=true
quarkus.openshift.build-strategy=docker
quarkus.kubernetes-client.trust-certs=true
# Kubernetes Secret
quarkus.kubernetes-config.secrets.enabled=true
quarkus.kubernetes-config.secrets=db-credentials
```
Save the file.
### 5. Build and deploy the application to Kubernetes
To build and deploy the reactive application, you can also use the following Quarkus CLI:
```
$ quarkus build
```
This command triggers the application build to generate a `fast-jar` file. Then the application `Jar` file is containerized using a Dockerfile, which was already generated in the `src/main/docker` directory when you created the project. Finally, the application image is pushed into the integrated container registry inside the OpenShift cluster.
The output should end with a `BUILD SUCCESS` message.
When you deploy the application to the developer sandbox or normal OpenShift cluster, you can find the application in the Topology view in the Developer perspective, as shown in the figure below.
![A screenshot of Red Hat OpenShift Dedicated. In the left sidebar menu Topology is highlighted, and in the main screen there is a Quarkus icon][8]
Image by: (Daniel Oh, CC BY-SA 4.0)
### 6. Verify the sensitive information
To verify that your Quarkus application can refer to the sensitive information from the Kubernetes Secret, get the route URL using the following `kubectl` command:
```
$ kubectl get route
```
The output is similar to this:
```
NAME                     HOST/PORT                                                               PATH   SERVICES                 PORT   TERMINATION   WILDCARD
quarkus-secret-example   quarkus-secret-example-doh-dev.apps.sandbox.x8i5.p1.openshiftapps.com          quarkus-secret-example   8080                 None
```
Use the [curl command][9] to access the RESTful API:
```
$ curl http://YOUR_ROUTE_URL/hello/security
```
The output:
```
{db.password=secret, db.username=admin}
```
Awesome! The above `username` and `password` are the same as those you stored in the `db-credentials` secret.
### Where to learn more
This guide has shown how Quarkus enables developers to externalize sensitive information using Kubernetes Secrets. Find additional resources to develop cloud-native microservices using Quarkus on Kubernetes here:
* [7 guides for developing applications on the cloud with Quarkus][10]
* [Extend Kubernetes service discovery with Stork and Quarkus][11]
* [Deploy Quarkus applications to Kubernetes using a Helm chart][12]
You can also watch this step-by-step [tutorial video][13] on how to manage Kubernetes Secrets with Quarkus.
--------------------------------------------------------------------------------
via: https://opensource.com/article/22/5/quarkus-kubernetes-secrets
作者：[Daniel Oh][a]
选题：[lkxed][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/daniel-oh
[b]: https://github.com/lkxed
[1]: https://opensource.com/sites/default/files/lead-images/rh_003601_05_mech_osyearbook2016_security_cc.png
[2]: https://kubernetes.io/docs/concepts/configuration/secret/
[3]: https://github.com/danieloh30/quarkus-secret-example.git
[4]: https://enterprisersproject.com/article/2019/8/kubernetes-secrets-explained-plain-english?intcmp=7013a000002qLH8AAM
[5]: https://quarkus.io/guides/cli-tooling#installing-the-cli
[6]: https://kustomize.io/
[7]: https://developers.redhat.com/developer-sandbox/get-started
[8]: https://opensource.com/sites/default/files/2022-05/quarkus.png
[9]: https://opensource.com/article/20/5/curl-cheat-sheet
[10]: https://opensource.com/article/22/4/developing-applications-cloud-quarkus
[11]: https://opensource.com/article/22/4/kubernetes-service-discovery-stork-quarkus
[12]: https://opensource.com/article/21/10/quarkus-helm-chart
[13]: https://youtu.be/ak9R9-E_0_k

130
sources/tech/20220524 Collision- Linux App to Verify ISO and Other Files.md Normal file
View File

@ -0,0 +1,130 @@
[#]: subject: "Collision: Linux App to Verify ISO and Other Files"
[#]: via: "https://www.debugpoint.com/2022/05/collision/"
[#]: author: "Arindam https://www.debugpoint.com/author/admin1/"
[#]: collector: "lkxed"
[#]: translator: "geekpi"
[#]: reviewer: " "
[#]: publisher: " "
[#]: url: " "
Collision: Linux App to Verify ISO and Other Files
======
The tutorial outlines the features and usage guide of Collision. It is a GUI-based, easy-to-use utility that lets you verify files using cryptographic hash functions.
### Why do you need to verify files?
Everyone downloads files every day over the internet. But many users never bother to verify their integrity or authenticity. That means whether the file is legitimate and not tampered with by any malicious codes.
Take an example of any [Linux Distributions][1]‘ ISO files which come as standard installer images. All popular distribution makers also provide a hash file alongside the ISO file. Using that file, you can easily compare the hash value of your downloaded file. And you can rest assured that your file is correct and not corrupted by any means.
Moreover, if you download a large file over an unstable internet connection, the file may get corrupted. IN those scenarios also, it helps to verify.
### Collision – Features and How to Use
The app – [Collision][2] uses Cryptographic Hash Functions to help you verify files. The cryptographic hash functions are popular algorithms that generate the file data into a fixed-length data stream via several encryption algorithms. The most popular ones are MD5, SHA-1, SHA-256 and SHA-512. All of these are supported by the Collision app.
In addition to that, Collision also presents a neat user interface which is simple and easy to use for every Linux user. Here’s how it looks.
![Collision – First Screen][3]
Firstly, it has two primary features. a) upload a file to get the checksum or hash values and b) compare the checksum with the uploaded file.
For example, if you have a simple file, you can upload it via the “Open a File” button or “Open” for re-uploading another file.
As you can see in the below image, the text file has the below checksum for various hash functions. Now you can share the file over the internet/with anyone, along with the checksum values for verification.
![Hash values of a test file][4]
Moreover, if someone tampers with the file (even with a single byte) or the file gets corrupted during distribution, then the hash value changes entirely.
Secondly, if you want to verify the integrity of a file you have downloaded, go to the Verify tab. Then upload the file and enter the hash value of the uploaded file you received.
If it matches, you should see a green tick showing its authenticity.
![Collision verifies a sample file with SHA-256][5]
In addition, here is another example where I have modified the test file and kept the values as same. This use case clearly states that it’s not valid for this file.
![Collision showing that a file is not valid][6]
#### An important note
It is worth mentioning here that the hash methods don’t verify the file meta attributes such as modify time, modify date, etc. If someone tampers any file and reverts it to its original content, the hash methods would term it a valid file.
Now, let’s see a typical example of validating an ISO file.
### Example of Using Collision to verify a sample ISO file of Ubuntu Linux
I am sure you download many ISO files while using Linux in general. So to illustrate, I have downloaded the popular Ubuntu ISO server image from the official Ubuntu download page.
![Ubuntu server ISO file and checksums][7]
The SHA256SUMS file has the below checksum value for the installer, as shown above.
![SHA-256 value of Ubuntu server ISO image][8]
After you download, open the Collision application and upload the ISO file via the Verify tab. Then copy the SHA-256 value and paste it to the checksum box on the left.
You should see that the file is authentic if you have correctly downloaded and followed the steps.
![Ubuntu server ISO image verified][9]
### How to Install Collision
The Collision app installation is effortless using Flatpak. You need to [set up Flatpak][10] for your Linux Distributions and click on the below link to install Collision.
[Install Collision via Flathub][11]
After installation, you should find it via the application menu of your distro.
### Is there another way to verify files without any app?
Yes, there are some built-in utilities available in all Linux distributions, which you can also use to verify the files and their integrity using the terminal.
The following terminal utilities can be used to determine the hash of any file. They are installed by default in all distros, and you can even use them for your shell script to automate.
```
md5sum <file name>
```
```
sha1sum <file name>
```
```
sha256sum <file name>
```
Using the above utilities, you can find out the hash value. But you need to compare them to verify manually.
![Verify files via command-line utilities][12]
### Closing Notes
I hope this guide helps you verify your files using the Collision GTK app. It is straightforward to use. Moreover, you can use the command line methods to verify any files you want when you are in the terminal. Also, it’s a best practice to always check for file integrity wherever possible.
--------------------------------------------------------------------------------
via: https://www.debugpoint.com/2022/05/collision/
作者：[Arindam][a]
选题：[lkxed][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://www.debugpoint.com/author/admin1/
[b]: https://github.com/lkxed
[1]: https://www.debugpoint.com/category/distributions
[2]: https://collision.geopjr.dev/
[3]: https://www.debugpoint.com/wp-content/uploads/2022/05/Collision-First-Screen.jpg
[4]: https://www.debugpoint.com/wp-content/uploads/2022/05/Hash-values-of-a-test-file.jpg
[5]: https://www.debugpoint.com/wp-content/uploads/2022/05/Collision-verifies-a-sample-file-with-SHA-256.jpg
[6]: https://www.debugpoint.com/wp-content/uploads/2022/05/Collision-showing-that-a-file-is-not-valid.jpg
[7]: https://www.debugpoint.com/wp-content/uploads/2022/05/Ubuntu-server-ISO-file-and-checksums.jpg
[8]: https://www.debugpoint.com/wp-content/uploads/2022/05/SHA-256-valud-of-Ubuntu-server-ISO-image.jpg
[9]: https://www.debugpoint.com/wp-content/uploads/2022/05/Ubuntu-server-ISO-image-verified.jpg
[10]: https://flatpak.org/setup/
[11]: https://dl.flathub.org/repo/appstream/dev.geopjr.Collision.flatpakref
[12]: https://www.debugpoint.com/wp-content/uploads/2022/05/Verify-files-via-command-line-utilities.jpg

234
sources/tech/20220524 pdfgrep- Use Grep Like Search on PDF Files in Linux Command Line.md Normal file
View File

@ -0,0 +1,234 @@
[#]: subject: "pdfgrep: Use Grep Like Search on PDF Files in Linux Command Line"
[#]: via: "https://itsfoss.com/pdfgrep/"
[#]: author: "Pratham Patel https://itsfoss.com/author/pratham/"
[#]: collector: "lkxed"
[#]: translator: " "
[#]: reviewer: " "
[#]: publisher: " "
[#]: url: " "
pdfgrep: Use Grep Like Search on PDF Files in Linux Command Line
======
Even if you use the Linux command line moderately, you must have come across the [grep command][1].
Grep is used to search for a pattern in a text file. It can do crazy powerful things, like search for new lines, search for lines where there are no uppercase characters, search for lines where the initial character is a number, and much, much more. Check out some [common grep command examples][2] if you are interested.
But grep works only on plain text files. It won’t work on PDF files because they are binary files.
This is where pdfgrep comes into the picture. It works like grep for PDF files. Let us have a look at that.
### Meet pdfgrep: grep like regex search for PDF files
[pdfgrep][3] tries to be compatible with GNU Grep, where it makes sense. Several of your favorite grep options are supported (such as -r, -i, -n or -c). You can use to search for text inside the contents of PDF files.
Though it doesn’t come pre-installed like grep, it is available in the repositories of most Linux distributions.
You can use your distribution’s [package manager][4] to install this awesome tool.
For users of Ubuntu and Debian-based distributions, use the apt command:
```
sudo apt install pdfgrep
```
For Red Hat and Fedora, you can use the dnf command:
```
sudo dnf install pdfgrep
```
Btw, do you run Arch? You can [use the pacman command][5]:
```
sudo pacman -S pdfgrep
```
### Using pdfgrep command
Now that pdfgrep is installed let me show you how to use it in most common scenarios.
If you have any experience with grep, then most of the options will feel familiar to you.
To demonstrate, I will be using [The Linux Command Line][6] PDF book, written by William Shotts. It’s one of the [few Linux books that are legally available for free][7].
The syntax for pdfgrep is as follows:
```
pdfgrep [PATTERN] [FILE.pdf]
```
#### Normal search
Let’s try doing a basic search for the text ‘xdg’ in the PDF file.
```
pdfgrep xdg TLCL-19.01.pdf
```
![simple search using pdfgrep][8]
This resulted in only one match… But a match nonetheless!
#### Case insensitive search
Most of the time, the term ‘xdg’ is used with capitalized alphabetical characters. So, let’s try doing a case-insensitive search. For a case insensitive search, I will use the –ignore-case option.
You can also use the shorter alternative, which is -i.
```
pdfgrep --ignore-case xdg TLCL-19.01.pdf
```
![case insensitive search using pdfgrep][9]
As you can see, I got more matches after turning on case insensitive searching.
#### Get a count of all matches
Sometimes, the user wants to know how many matches were found of the word. Let’s see how many times the word ‘Linux’ is mentioned (with case insensitive matching).
The option to use in this scenario is –count (or -c for short).
```
pdfgrep --ignore-case linux TLCL-19.01.pdf --count
```
![getting a count of matches using pdfgrep][10]
Woah! Linux was mentioned 1200 times in this book… That was unexpected.
#### Show page number
Regular text files are giant monolithic files. There are no pages. But a PDF file has pages. So, you can see where the pattern was found and on which page. Use the –page-number option to show the page number where the pattern was matched. You can also use the `-n` option as a shorter alternative.
Let us see how it works with an example. I want to see the pages where the word ‘awk’ matches. I added a space at the end of the pattern to prevent matching with words like ‘awkward’, getting unintentional matches would be *awkward*. Instead of escaping space with a backslash, you can also enclose it in single quotes ‘awk ‘.
```
pdfgrep --page-number --ignore-case awk\ TLCL-19.01.pdf
```
![show which pattern was found on which page using pdfgrep][11]
The word ‘awk’ was found twice on page number 333, once on page 515 and once again on page 543 in the PDF file.
#### Show match count per page
Do you want to know how many matches were found on which page instead of showing the matches themselves? If you said yes, well it is your lucky day!
Using the –page-count option does exactly that. As a shorter alternative, you use the -p option. When you provide this option to pdfgrep, it is assumed that you requested `-n` as well.
Let’s take a look at how the output looks. For this example, I will see where the [ln command][12] is used in the book.
```
pdfgrep --page-count ln\ TLCL-19.01.pdf
```
![show which page has how many matches using pdfgrep][13]
The output is in the form of ‘page number: matches’. This means, on page number 4, the command (or rather “pattern”) was found only once. But on page number 57, pdfgrep found 4 matches.
#### Get some context
When the number of matches found is quite big, it is nice to have some context. For that, pdfgrep provides some options.
* –after-context NUM: Print NUM of lines that come after the matching lines (or use `-A`)
* –before-context NUM: Print NUM of lines that are before the matching lines (or use `-B`)
* –context NUM: Print NUM of lines that are before and come after the matching lines (or use `-C`)
Let’s find ‘XDG’ in the PDF file, but this time, with a little more context ( ͡❛ ͜ʖ ͡❛)
**Context after matches**
Using the –after-context option along with a number, I can see which lines come after the line(s) that match. Below is an example of how it looks.
```
pdfgrep --after-context 2 XDG TLCL-19.01.pdf
```
![using '--after-context' option in pdfgrep][14]
**Context before matches**
Same thing can be done for scenarios when you need to know what lines are present before the line that matches. In that case, use the –before-context option, along with a number. Below is an example demonstrating usage of this option.
```
pdfgrep --before-context 2 XDG TLCL-19.01.pdf
```
![using '--before-context' option in pdfgrep][15]
**Context around matches**
If you want to see which lines are present before and come after the line that matched, use the –context option and also provide a number. Below is an example.
```
pdfgrep --context 2 XDG TLCL-19.01.pdf
```
![using '--context' option in pdfgrep][16]
#### Caching
A PDF file consists of images as well as text. When you have a large PDF file, it might take some time to skip other media, extract text and then “grep” it. Doing it often and waiting every time can get frustrating.
For that reason, the –cache option exists. It caches the rendered text to speed up grep-ing. This is especially noticeable on large files.
```
pdfgrep --cache --ignore-case grep TLCL-19.01.pdf
```
![getting faster results using the '--cache' option][17]
While not the be-all and end-all, I carried out a search 4 times. Twice with cache enable and twice without cache enable. To show the speed difference, I used the time command. Look closely at the time indicated by ‘real’ value.
As you can see, the commands that include –cache option were completed faster than the ones that didn’t include it.
Additionally, I suppressed the output using the –quiet option for faster completion.
#### Password protected PDF files
Yes, pdfgrep supports grep-ing even password-protected files. All you have to do is use the –password option, followed by the password.
I do not have a password-protected file to demonstrate with, but you can use this option in the following manner:
```
pdfgrep --password [PASSWORD] [PATTERN] [FILE.pdf]
```
### Conclusion
pdfgrep is a very handy tool if you are dealing with PDF files and want the functionality of ‘grep’, but for PDF files. A reason why I like pdfgrep is that it tries to be compatible with GNU Grep.
Give it a try and let me know what you think of pdfgrep.
--------------------------------------------------------------------------------
via: https://itsfoss.com/pdfgrep/
作者：[Pratham Patel][a]
选题：[lkxed][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://itsfoss.com/author/pratham/
[b]: https://github.com/lkxed
[1]: https://linuxhandbook.com/what-is-grep/
[2]: https://linuxhandbook.com/grep-command-examples/
[3]: https://pdfgrep.org/
[4]: https://itsfoss.com/package-manager/
[5]: https://itsfoss.com/pacman-command/
[6]: https://www.linuxcommand.org/tlcl.php
[7]: https://itsfoss.com/learn-linux-for-free/
[8]: https://itsfoss.com/wp-content/uploads/2022/05/01_pdfgrep_normal_search-1-800x308.webp
[9]: https://itsfoss.com/wp-content/uploads/2022/05/02_pdfgrep_case_insensitive-800x413.webp
[10]: https://itsfoss.com/wp-content/uploads/2022/05/03_pdfgrep_count-800x353.webp
[11]: https://itsfoss.com/wp-content/uploads/2022/05/04_pdfgrep_page_number-800x346.webp
[12]: https://linuxhandbook.com/ln-command/
[13]: https://itsfoss.com/wp-content/uploads/2022/05/05_pdfgrep_pg_count-800x280.webp
[14]: https://itsfoss.com/wp-content/uploads/2022/05/06_pdfgrep_after_context-800x340.webp
[15]: https://itsfoss.com/wp-content/uploads/2022/05/07_pdfgrep_before_context-800x356.webp
[16]: https://itsfoss.com/wp-content/uploads/2022/05/08_pdfgrep_context-800x453.webp
[17]: https://itsfoss.com/wp-content/uploads/2022/05/09_pdfgrep_cache-800x575.webp

129
translated/tech/20220520 Customize GNOME 42 with A Polished Look.md Normal file
View File

@ -0,0 +1,129 @@
[#]: subject: "Customize GNOME 42 with A Polished Look"
[#]: via: "https://www.debugpoint.com/2022/05/customize-gnome-42-look-1/"
[#]: author: "Arindam https://www.debugpoint.com/author/admin1/"
[#]: collector: "lkxed"
[#]: translator: "geekpi"
[#]: reviewer: " "
[#]: publisher: " "
[#]: url: " "
自定义 GNOME 42 的精致外观
======
一个关于如何在 5 分钟内为你最喜欢的 GNOME 桌面提供精美外观的教程。
你可以通过多种方式使用图标、主题、光标和壁纸自定义你最喜爱的 GNOME 桌面。本文向你展示了如何使 GNOME 42 桌面看起来更加精致。GNOME 42 桌面环境可用于最近发布的 Ubuntu 22.04 LTS 和 Fedora 36。
在你进一步阅读之前，这是并排比较（之前和之后）的外观。
![GNOME before customisation][1]
![GNOME after customisation][2]
我将把本教程分为两个部分。
第一部分涉及设置和安装所需的软件包。其次，如何应用各种设置来获得你想要的外观。
本教程主要在 Ubuntu 22.04 LTS 上测试。但是，它应该适用于 Ubuntu 和 Fedora 的其他变体。
### 使用精致外观自定义 GNOME 42
#### 设置
* 首先，为你的系统启用 Flatpak，因为我们需要安装扩展管理器来下载本教程所需的 GNOME Shell 扩展。
* 因此，要做到这一点，请打开一个终端并运行以下命令。
```
sudo apt install flatpak gnome-software-plugin-flatpakflatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
```
* 完成后重启计算机。
* 然后从终端运行以下命令来安装扩展管理器应用以下载 GNOME Shell 扩展。
```
flatpak install flathub com.mattjakeman.ExtensionManager
```
* 打开扩展管理器应用并安装两个扩展。第一个是浮动 dock，它具有超酷的 dock，你可以在桌面上的任何位置移动。其次，安装用户主题扩展来帮助你在 Ubuntu Linux 中安装外部 GTK 主题。
![User Themes Extension][3]
![Floating Dock Extension][4]
* 其次，使用以下命令安装 [Materia 主题][5]。你必须构建它，因为它没有任何可执行文件。在 Ubuntu 中依次运行以下命令进行安装。
```
git clone https://github.com/ckissane/materia-theme-transparent.gitcd materia-theme-transparentmeson _buildmeson install -C _build
```
* 此外，请从以下链接下载 [Kora 图标主题][6]。下载后解压文件，将以下四个文件夹复制到 `/home/<用户名>/.icons` 路径下。如果 .icons 文件夹不存在，请创建它。
[下载 Kora 图标主题][7]
![Kora Icon Theme][8]
* 除了上述更改，从下面的链接下载 Bibata 光标主题。下载后，解压文件夹并将其复制到相同的 `/home/<用户名>/.icons` 文件夹中。
[下载 Bibata 光标主题][9]
* 除了上述之外，如果你想要一个与上述主题相匹配的漂亮字体，请从 Google Fonts [下载 Robot font][10] 并将它们复制到 `/home/<user name>/.fonts` 文件夹。
* 最后，再次重启系统。
#### 配置
* 打开扩展管理器，启用浮动 dock 和用户主题，并禁用 Ubuntu Dock。
![Changes to Extensions][11]
* 此外，打开浮动 dock 设置并进行以下更改。
![Floating Dock Settings][12]
* 此外，打开 [GNOME Tweak Tool][13]，然后转到外观选项卡。设置以下内容。
* 光标：Bibata-Original-Ice
* Shell 主题：Materia
* 图标：Kora
* 除此之外，你可能还想更改字体。为此，请转到字体选项卡并将文档和界面更改为 Robot 10pt。
* 或者，你也可以从 Ubuntu 22.04 的默认设置中更改强调色和样式。
* 最后，根据你的喜好下载漂亮的壁纸。对于本教程，我从[这里][14]下载了一个示例壁纸。
* 如果一切顺利，你应该有一个漂亮的桌面，如下图所示。
![Customize GNOME 42 – Final Look][15]
享受精致的 GNOME 42。干杯。
--------------------------------------------------------------------------------
via: https://www.debugpoint.com/2022/05/customize-gnome-42-look-1/
作者：[Arindam][a]
选题：[lkxed][b]
译者：[geekpi](https://github.com/geekpi)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://www.debugpoint.com/author/admin1/
[b]: https://github.com/lkxed
[1]: https://i2.wp.com/www.debugpoint.com/wp-content/uploads/2022/05/GNOME-before-customisation.jpg?ssl=1
[2]: https://i0.wp.com/www.debugpoint.com/wp-content/uploads/2022/05/GNOME-after-customisation.jpg?ssl=1
[3]: https://www.debugpoint.com/wp-content/uploads/2022/05/User-Themes-Extension2.jpg
[4]: https://www.debugpoint.com/wp-content/uploads/2022/05/Floating-Doc-Extension.jpg
[5]: https://github.com/ckissane/materia-theme-transparent
[6]: https://github.com/bikass/kora/
[7]: https://github.com/bikass/kora/archive/refs/heads/master.zip
[8]: https://www.debugpoint.com/wp-content/uploads/2022/05/Kora-Icon-Theme.jpg
[9]: https://www.pling.com/p/1197198/
[10]: https://fonts.google.com/specimen/Roboto
[11]: https://www.debugpoint.com/wp-content/uploads/2022/05/Changes-to-Extensions.jpg
[12]: https://www.debugpoint.com/wp-content/uploads/2022/05/Floating-Dock-Settings.jpg
[13]: https://www.debugpoint.com/2018/05/customize-your-ubuntu-desktop-using-gnome-tweak/
[14]: https://www.pexels.com/photo/colorful-blurred-image-6985048/
[15]: https://www.debugpoint.com/wp-content/uploads/2022/05/Customize-GNOME-42-Final-Look.jpg