Usando Systemd para Gerenciar Grupos de Controle

Apresenta conceitos de grupos no Oracle Linux e mostra como o systemd organiza e gerencia o controle de recursos.

Os grupos de controle, chamados de cgroups, são um recurso do kernel do Oracle Linux que organiza serviços do systemd e, se necessário, processos individuais (PIDs), em grupos hierárquicos para alocar recursos do sistema, como CPU, memória e E/S.

Por exemplo, se você precisar dividir o recurso da CPU entre três serviços systemd, myservice1.service, myservice2.service e myservice3.service, em uma proporção de 150:100:50, poderá usar as ferramentas systemd para atribuir a cada serviço cgroup correspondente um peso de CPU que corresponda ao seu compartilhamento de destino.

Observação

O systemd é responsável por criar e gerenciar seu cgroups no sistema de arquivos virtual /sys/fs/cgroup/.

O pacote systemd fornece maneiras seguras e de alto nível para configurar recursos cgroup, como o uso de arquivos drop-in ou o comando systemctl set-property. A modificação direta de objetos de systemd no sistema de arquivos virtuais /sys/fs/cgroup/ não é recomendada.

Por padrão, systemd cria uma cgroup para o seguinte:

  • Cada serviço systemd configurado no host.

    Por exemplo, um servidor pode ter o grupo de controle NetworkManager.service para agrupar processos pertencentes ao serviço NetworkManager e o grupo de controle firewalld.service para agrupar processos pertencentes ao serviço firewalld e assim por diante.

  • Cada usuário (UID) no host.

A funcionalidade cgroup é montada como um sistema de arquivos virtual em /sys/fs/cgroup.

Cada cgroup tem uma pasta correspondente no sistema de arquivos /sys/fs/cgroup. Por exemplo, o cgroups criado pelo systemd para os serviços que ele gerencia pode ser visto executando o comando ls -l /sys/fs/cgroup/system.slice | grep ".service", conforme mostrado no seguinte bloco de código de amostra:

ls -l /sys/fs/cgroup/system.slice | grep ".service"
...root root 0 Mar 22 10:47 atd.service
...root root 0 Mar 22 10:47 auditd.service
...root root 0 Mar 22 10:47 chronyd.service
...root root 0 Mar 22 10:47 crond.service
...root root 0 Mar 22 10:47 dbus-broker.service
...root root 0 Mar 22 10:47 dtprobed.service
...root root 0 Mar 22 10:47 firewalld.service
...root root 0 Mar 22 10:47 httpd.service
...

Você também pode criar cgroups personalizado fora das ramificações systemd, por exemplo, em um local como /sys/fs/cgroup/MyGroups/, e atribuir IDs de processo (PIDs) a diferentes cgroups de acordo com as necessidades do sistema. No entanto, essa abordagem só deve ser usada para cenários específicos, como depuração ou teste temporários. Para a maioria dos casos de uso, recomendamos o uso do systemd para configurar o cgroups para garantir o gerenciamento correto e persistente de recursos.

O Oracle Linux fornece dois tipos de grupos de controle:

Grupos de controle versão 1 (cgroups v1)

Esses grupos fornecem uma hierarquia de controladores por recurso.

Cada recurso, como CPU, memória, E/S e assim por diante, tem sua própria hierarquia de grupo de controle. Uma desvantagem desse grupo é a dificuldade de estabelecer uma coordenação adequada do uso de recursos entre grupos que podem pertencer a diferentes hierarquias de processos.

Grupos de controle versão 2 (cgroups v2)

Esses grupos fornecem uma única hierarquia de grupo de controle na qual todos os controladores de recursos são montados. Nesta hierarquia, você pode obter uma melhor coordenação adequada dos usos de recursos em diferentes controladores de recursos. Esta versão é uma melhoria em relação ao cgroups v1, cuja flexibilidade excessiva impediu a coordenação adequada do uso de recursos entre os consumidores do sistema.

O Oracle Linux 8 inclui ambas as versões, com o cgroups v1 ativado e montado por padrão. O Oracle Linux 9 também fornece as duas versões, mas ativa e monta o cgroups v2 por padrão.

O Oracle Linux 10 oferece apenas a implementação dos grupos de controle versão 2. cgroups v1 está obsoleto e não está disponível. cgroups v2 é ativado e montado por padrão.

Para obter mais informações sobre grupos de controle, consulte as páginas manuais cgroups(7) e sysfs(5).

Sobre Grupos de Controle e systemd

Os grupos de controle podem ser usados pelo sistema systemd e pelo gerenciador de serviços para gerenciamento de recursos. O systemd usa esses grupos para organizar unidades e serviços que consomem recursos. Para obter mais informações sobre systemd, consulte Managing the System With systemd.

systemd fornece diferentes tipos de unidade, três dos quais são para fins de controle de recursos:

  • Serviço: Um processo ou um grupo de processos cujas configurações são baseadas em um arquivo de configuração de unidade. Os serviços abrangem processos especificados em uma "coleta" para que systemd possa iniciar ou interromper os processos como um conjunto. Os nomes de serviço seguem o formato name.service.

  • Escopo: Um grupo de processos criados externamente, como sessões do usuário, contêineres, máquinas virtuais etc.

    Semelhante aos serviços, os escopos encapsulam esses processos criados e são iniciados ou interrompidos pelos processos arbitrários e, em seguida, registrados por systemd no runtime. Os nomes de escopo seguem o formato name.scope.

  • Fatia: Um grupo de unidades organizadas hierarquicamente em que os serviços e escopos estão localizados.

    Assim, as próprias fatias não contêm processos. Em vez disso, os escopos e os serviços em uma fatia definem os processos. Cada nome de uma unidade de segmento corresponde ao caminho para um local na hierarquia. Os segmentos raiz, geralmente user.slice para todos os processos baseados no usuário e system.slice para processos baseados no sistema, são criados automaticamente na hierarquia. Segmentos pai existem imediatamente abaixo do segmento raiz e seguem o formato parent-name.slice. Esses segmentos raiz podem então ter sub-segmentos em vários níveis.

O serviço, o escopo e as unidades de intervalo são mapeados diretamente para objetos na hierarquia do grupo de controle. Quando essas unidades são ativadas, elas são mapeadas diretamente para controlar os caminhos do grupo que são criados a partir dos nomes das unidades. Para exibir o mapeamento entre os tipos de unidade de recurso systemd e os grupos de controle, digite:

sudo systemd-cgls
Working directory /sys/fs/cgroup:
├─user.slice (#1243)
│ → trusted.invocation_id: 50ce3909b2644f919ee420adc39edb4b
│ ├─user-1001.slice (#4167)
│ │ → trusted.invocation_id: 02e80a960d4549a7a9c69ce0fb546c26
│ │ ├─session-2.scope (#4405)
│ │ │ ├─2417 sshd: alice [priv]
│ │ │ ├─2430 sshd: alice@pts/0
│ │ │ ├─2431 -bash
│ │ │ ├─2689 sudo systemd-cgls
│ │ │ ├─2691 systemd-cgls
│ │ │ └─2692 less
...
│   └─user@984.service … (#3827)
│     → trusted.delegate: 1
│     → trusted.invocation_id: 09b47ce9f3124239b75814114353f3f2
│     └─init.scope (#3861)
│       ├─2058 /usr/lib/systemd/systemd --user
│       └─2099 (sd-pam)
├─init.scope (#19)
│ └─1 /usr/lib/systemd/systemd --switched-root --system --deserialize 17
└─system.slice (#53)
...
  ├─chronyd.service (#2467)
  │ → trusted.invocation_id: c0f77aaa9c7844e6bef6a6898ae4dd56
  │ └─1358 /usr/sbin/chronyd -F 2
  ├─auditd.service (#2331)
  │ → trusted.invocation_id: 756808add6a348609316c9e8c1801846
  │ └─1310 /sbin/auditd
  ├─tuned.service (#3079)
  │ → trusted.invocation_id: 2c358135fc46464d862b05550338d4f4
  │ └─1415 /usr/bin/python3 -Es /usr/sbin/tuned -l -P
  ├─systemd-journald.service (#1651)
  │ → trusted.invocation_id: 7cb7ccb14e044a899aadf47bbb583ada
  │ └─977 /usr/lib/systemd/systemd-journald
  ├─atd.service (#3623)
  │ → trusted.invocation_id: 597a7a4e5646468db407801b8562d869
  │ └─1915 /usr/sbin/atd -f
  ├─sshd.service (#3419)
  │ → trusted.invocation_id: 490504a683fc4311ab0fbeb0864a1a34
  │ └─1871 sshd: /usr/sbin/sshd -D [listener] 0 of 10-100 startups
...

Para obter um exemplo de como usar comandos systemd, como systemctl, para gerenciar recursos, consulte Controlando o Acesso aos Recursos do Sistema. Para obter mais detalhes técnicos, consulte as páginas do manual systemctl(1), systemd-cgls(1) e systemd.resource-control(5).

Usando systemd para Gerenciar cgroups v2

Mostra como systemd estrutura cgroups v2 para serviços e usuários e como inspecionar a hierarquia.

O método preferido de gerenciar a alocação de recursos com cgroups v2 é usar a funcionalidade de grupo de controle fornecida pelo systemd.

Observação

Para obter informações sobre como ativar a funcionalidade cgroups v2 no sistema, consulte Gerenciando Recursos Usando Grupos de Controle

Por padrão, o systemd cria uma pasta cgroup para cada serviço systemd configurado no host. O systemd nomeia essas pastas usando o formato servicename.service, em que servicename é o nome do serviço associado à pasta.

Para ver uma lista das pastas cgroup que o systemd cria para os serviços, execute o comando ls na ramificação system.slice do sistema de arquivos cgroup, conforme mostrado no seguinte bloco de código de amostra:

ls /sys/fs/cgroup/system.slice/
...                     ...                           ...
app_service1.service    cgroup.subtree_control        httpd.service
app_service2.service    chronyd.service               ...  
...                     crond.service                 ...
cgroup.controllers      dbus-broker.service           ...
cgroup.events           dtprobed.service              ...
cgroup.freeze           firewalld.service             ...
...                     gssproxy.service              ...
...                     ...                           ...

No bloco de comandos anterior:

  • As pastas app_service1.service e app_service2.service representam serviços de aplicativo personalizados que podem ser executados no sistema.

Além dos grupos de controle de serviço, o systemd também cria uma pasta cgroup para cada usuário no host.

Para ver o cgroups criado para cada usuário, você pode executar o comando ls na ramificação user.slice do sistema de arquivos cgroup, conforme mostrado no seguinte bloco de código de amostra:

ls /sys/fs/cgroup/user.slice/
cgroup.controllers      cgroup.subtree_control        user-1001.slice
cgroup.events           cgroup.threads                user-982.slice
cgroup.freeze           cgroup.type                   ...
...                     ...                           ...
...                     ...                           ...
...                     ...                           ...

No bloco de código anterior:

  • Cada pasta cgroup do usuário é nomeada usando o formato user-UID.slice. Portanto, o grupo de controle user-1001.slice é para um usuário cujo UID é 1001, por exemplo.

O systemd fornece acesso de alto nível aos recursos do controlador de recursos cgroups e kernel para que você não precise acessar o sistema de arquivos diretamente.

Por exemplo, para definir o peso da CPU de um serviço chamado app_service1.service, execute o comando systemctl set-property da seguinte forma:

sudo systemctl set-property app_service1.service CPUWeight=150

Assim, o systemd permite gerenciar a distribuição de recursos em um nível de aplicativo, em vez do nível PID do processo usado ao configurar o cgroups sem usar a funcionalidade systemd.

Sobre fatias e alocação de recursos em systemd

Esta seção analisa a maneira como systemd inicialmente divide cada um dos controladores de kernel padrão, por exemplo, CPU, memory e blkio, em partes chamadas "segmentos", conforme ilustrado pelo seguinte exemplo de gráfico de pizza:

Observação

Você também pode criar fatias personalizadas para a distribuição de recursos, conforme mostrado na seção Definindo Opções do Controlador de Recursos e Criando Fatias Personalizadas.

Gráfico de pizza com 3 fatias de tamanho igual, rotuladas como Sistema, Máquina e Usuário. Usuário e Sistema são divididos em sub-segmentos.

Como mostra o gráfico de pizza anterior, por padrão, cada controlador de recursos é dividido igualmente entre as 3 fatias a seguir:

  • Sistema (system.slice).

  • Usuário (user.slice).

  • Máquina (machine.slice).

A lista a seguir analisa cada fatia mais de perto. Para fins de discussão, os exemplos na lista se concentram no controlador da CPU.

Sistema (system.slice)

Este segmento de recurso é usado para gerenciar a alocação de recursos entre daemons e unidades de serviço.

Conforme mostrado no exemplo de gráfico de pizza anterior, o segmento do sistema é dividido em subsegmentos adicionais. Por exemplo, no caso de recursos de CPU, podemos ter alocações de subsegmento no segmento do sistema que incluem o seguinte:
  • httpd.service (CPUWeight=100)

  • sshd.service (CPUWeight =100)

  • crond.service (CPUWeight =100)

  • app1.service (CPUWeight =100)

  • app2.service (CPUWeight =100)

Na lista anterior, app1.service e app2.service representam serviços de aplicativo personalizados que podem ser executados no sistema.
Usuário (user.slice)
Esta fatia de recurso é usada para gerenciar a alocação de recursos entre as sessões do usuário. Um único segmento é criado para cada UID independentemente de quantos logins o usuário associado tenha ativo no servidor. Continuando com nosso exemplo de gráfico de pizza, os subsegmentos podem ser os seguintes:
  • user1 (CPUWeight=100, UID=982)

  • user2 (CPUWeight=100, UID=1001)

Máquina (machine.slice)
Essa fatia do recurso é usada para gerenciar a alocação de recursos entre máquinas virtuais hospedadas, como convidados KVM e Contêineres Linux. A fatia da máquina só está presente em um servidor se o servidor estiver hospedando máquinas virtuais ou Linux Containers.
Observação

As alocações de compartilhamento não definem um limite máximo para um recurso.

Nos exemplos anteriores, o segmento user.slice tem 2 usuários: user1 e user2. Cada usuário recebe um compartilhamento igual do recurso de CPU disponível para o user.slice pai. No entanto, se os processos associados ao user1 estiverem ociosos e não exigirem nenhum recurso da CPU, seu compartilhamento de CPU estará disponível para alocação para o user2, se necessário. Em tal situação, user2 pode até ser alocado para todo o recurso da CPU distribuído ao user.slice pai, se for exigido por outros usuários.

Para limitar o recurso de CPU, você precisaria definir a propriedade CPUQuota como a porcentagem necessária.

Fatias, Serviços e Escopos na Hierarquia de cgroup

A analogia do gráfico de pizza usada nas seções anteriores é uma maneira útil de conceituar a divisão de recursos em fatias. No entanto, em termos de organização estrutural, os grupos de controle são organizados em uma hierarquia. Você pode exibir a hierarquia de grupos de controle systemd no sistema executando o comando systemd-cgls da seguinte forma:

Dica

Para ver toda a hierarquia cgroup, começando pelo segmento raiz -.slice, como no exemplo a seguir, certifique-se de executar systemd-cgls de fora do ponto de montagem do grupo de controle /sys/fs/cgroup/.

Caso contrário, se você executar o comando de dentro de /sys/fs/cgroup/, a saída começará no local cgroup do qual o comando foi executado. Consulte systemd-cgls(1) para obter mais informações.

systemd-cgls
Control group /:
-.slice
...
├─user.slice (#1429)
│ → user.invocation_id: 604cf5ef07fa4bb4bb86993bb5ec15e0
│ ├─user-982.slice (#4131)
│ │ → user.invocation_id: 9d0d94d7b8a54bcea2498048911136c8
│ │ ├─session-c1.scope (#4437)
│ │ │ ├─2416 /usr/bin/sudo -u ocarun /usr/libexec/oracle-cloud-agent/plugins/runcommand/runcommand
│ │ │ └─2494 /usr/libexec/oracle-cloud-agent/plugins/runcommand/runcommand
│ │ └─user@982.service … (#4199)
│ │   → user.delegate: 1
│ │   → user.invocation_id: 37c7aed7aa6e4874980b79616acf0c82
│ │   └─init.scope (#4233)
│ │     ├─2437 /usr/lib/systemd/systemd --user
│ │     └─2445 (sd-pam)
│ └─user-1001.slice (#7225)
│   → user.invocation_id: ce93ad5f5299407e9477964494df63b7
│   ├─session-2.scope (#7463)
│   │ ├─20304 sshd: oracle [priv]
│   │ ├─20404 sshd: oracle@pts/0
│   │ ├─20405 -bash
│   │ ├─20441 systemd-cgls
│   │ └─20442 less
│   └─user@1001.service … (#7293)
│     → user.delegate: 1
│     → user.invocation_id: 70284db060c1476db5f3633e5fda7fba
│     └─init.scope (#7327)
│       ├─20395 /usr/lib/systemd/systemd --user
│       └─20397 (sd-pam)
├─init.scope (#19)
│ └─1 /usr/lib/systemd/systemd --switched-root --system --deserialize 28
└─system.slice (#53)
 ...
  ├─dbus-broker.service (#2737)
  │ → user.invocation_id: 2bbe054a2c4d49809b16cb9c6552d5a6
  │ ├─1450 /usr/bin/dbus-broker-launch --scope system --audit
  │ └─1457 dbus-broker --log 4 --controller 9 --machine-id 852951209c274cfea35a953ad2964622 --max-bytes 536870912 --max-fds 4096 --max-matches 131072 --audit
 ...
  ├─chronyd.service (#2805)
  │ → user.invocation_id: e264f67ad6114ad5afbe7929142faa4b
  │ └─1482 /usr/sbin/chronyd -F 2
  ├─auditd.service (#2601)
  │ → user.invocation_id: f7a8286921734949b73849b4642e3277
  │ ├─1421 /sbin/auditd
  │ └─1423 /usr/sbin/sedispatch
  ├─tuned.service (#3349)
  │ → user.invocation_id: fec7f73678754ed687e3910017886c5e
  │ └─1564 /usr/bin/python3 -Es /usr/sbin/tuned -l -P
  ├─systemd-journald.service (#1837)
  │ → user.invocation_id: bf7fb22ba12f44afab3054aab661aedb
  │ └─1068 /usr/lib/systemd/systemd-journald
  ├─atd.service (#3961)
  │ → user.invocation_id: 1c59679265ab492482bfdc9c02f5eec5
  │ └─2146 /usr/sbin/atd -f
  ├─sshd.service (#3757)
  │ → user.invocation_id: 57e195491341431298db233e998fb180
  │ └─2097 sshd: /usr/sbin/sshd -D [listener] 0 of 10-100 startups
  ├─crond.service (#3995)
  │ → user.invocation_id: 4f5b380a53db4de5adcf23f35d638ff5
  │ └─2150 /usr/sbin/crond -n
  ...

O exemplo de saída anterior mostra como todos os grupos de controle "*.slice" residem no segmento raiz -.slice. Abaixo do segmento raiz, você pode ver os grupos de controle user.slice e system.slice, cada um com seus próprios subsegmentos cgroup filhos.

Examinando a saída do comando systemd-cgls , você pode ver como, exceto para a raiz -.slice, todos os processos estão nos nós folha. Este acordo é aplicado pelo cgroups v2, em uma regra chamada regra "nenhum processo interno". Consulte cgroups (7) para obter mais informações sobre a regra "nenhum processo interno".

A saída no exemplo de comando systemd-cgls anterior também mostra como as fatias podem ter grupos de controle filho descendentes que são escopos systemd. Os escopos systemd são revisados na seção a seguir.

escopos systemd

O escopo systemd é um tipo de unidade systemd que agrupa os processos do service worker do sistema que foram iniciados independentemente de systemd. As unidades de escopo são transientes cgroups criados programaticamente usando as interfaces de barramento de systemd.

Por exemplo, no código de amostra a seguir, o usuário com UID 1001 executou o comando systemd-cgls e a saída mostra que session-2.scope foi criado para processos que o usuário gerou independentemente de systemd (incluindo o processo para o próprio comando, 21380 sudo systemd-cgls):

Observação

No exemplo a seguir, o comando foi executado de dentro do ponto de montagem do grupo de controle /sys/fs/cgroup/. Portanto, em vez do segmento raiz, a saída começa no local cgroup no qual o comando foi executado.
sudo systemd-cgls
Working directory /sys/fs/cgroup:
...
├─user.slice (#1429)
│ → user.invocation_id: 604cf5ef07fa4bb4bb86993bb5ec15e0
│ → trusted.invocation_id: 604cf5ef07fa4bb4bb86993bb5ec15e0
...
│ └─user-1001.slice (#7225)
│   → user.invocation_id: ce93ad5f5299407e9477964494df63b7
│   → trusted.invocation_id: ce93ad5f5299407e9477964494df63b7
│   ├─session-2.scope (#7463)
│   │ ├─20304 sshd: oracle [priv]
│   │ ├─20404 sshd: oracle@pts/0
│   │ ├─20405 -bash
│   │ ├─21380 sudo systemd-cgls
│   │ ├─21382 systemd-cgls
│   │ └─21383 less
│   └─user@1001.service … (#7293)
│     → user.delegate: 1
│     → trusted.delegate: 1
│     → user.invocation_id: 70284db060c1476db5f3633e5fda7fba
│     → trusted.invocation_id: 70284db060c1476db5f3633e5fda7fba
│     └─init.scope (#7327)
│       ├─20395 /usr/lib/systemd/systemd --user
│       └─20397 (sd-pam)

Definindo Opções do Controlador de Recursos e Criando Fatias Personalizadas

Demonstra três abordagens — arquivos de unidade, drop-ins e systemctl set-property — para o ajuste fino de controladores de recursos e layouts de segmento.

systemd fornece os seguintes métodos para definir opções de controlador de recursos, como CPUWeight, CPUQuota etc., para personalizar a alocação de recursos no sistema:

  • Utilizando arquivos de unidade de serviço.

  • Usando arquivos drop-in.

  • Usando o comando systemctl set-property.

As seções a seguir fornecem exemplos de procedimentos para a utilização de cada um desses métodos para configurar recursos e segmentos no sistema.

Usando Arquivos de Unidade de Serviço

Para definir opções em um arquivo de unidade de serviço, execute as seguintes etapas:

  1. Crie o arquivo /etc/systemd/system/myservice1.service com o seguinte conteúdo:
    [Service]
    Type=oneshot
    ExecStart=/usr/lib/systemd/generate_load.sh
    TimeoutSec=0
    StandardOutput=tty
    RemainAfterExit=yes
    
    [Install]
    WantedBy=multi-user.target
  2. O serviço criado na etapa anterior requer um script bash /usr/lib/systemd/generate_load.sh. Crie o arquivo com o seguinte conteúdo: de
    #!/bin/bash
    for i in {1..4};do while : ; do : ; done & done
  3. Torne o script executável:
    sudo chmod +x /usr/lib/systemd/generate_load.sh
  4. Ative e inicie o serviço:
    sudo systemctl enable myservice1 --now
  5. Execute o comando systemd-cgls e confirme se o serviço myservice1 está em execução em system.slice:
    systemd-cgls
    Control group /:
    -.slice
    ...
    ├─user.slice (#1429)
    ...
    └─system.slice (#53)
      ...
      ├─myservice1.service (#7939)
      │ → user.invocation_id: e227f8f288444fed92a976d391e6a897
      │ ├─22325 /bin/bash /usr/lib/systemd/generate_load.sh
      │ ├─22326 /bin/bash /usr/lib/systemd/generate_load.sh
      │ ├─22327 /bin/bash /usr/lib/systemd/generate_load.sh
      │ └─22328 /bin/bash /usr/lib/systemd/generate_load.sh
      ├─pmie.service (#4369)
      │ → user.invocation_id: 68fcd40071594481936edf0f1d7a8e12
       ...
  6. Criar uma fatia personalizada para o serviço.

    Adicione a linha Slice=my_custom_slice.slice à seção [Service] no arquivo myservice1.service, criado em uma etapa anterior, conforme mostrado no seguinte bloco de código:

    [Service]
    Slice=my_custom_slice.slice
    Type=oneshot
    ExecStart=/usr/lib/systemd/generate_load.sh
    TimeoutSec=0
    StandardOutput=tty
    RemainAfterExit=yes
    
    [Install]
    WantedBy=multi-user.target
    
    Atenção

    Use sublinhados em vez de traços para separar termos em nomes de segmentos.

    Em systemd, um traço no nome de uma fatia é um caractere especial: em systemd, traços em nomes de fatias são utilizados para descrever o caminho completo cgroup para a fatia (a partir da fatia raiz).

    Por exemplo, se você especificar um nome de segmento como "my-custom-slice.slice", em vez de criar um segmento com esse nome, o systemd criará o seguinte caminho cgroups abaixo do segmento raiz: my.slice/my-custom.slice/my-custom-slice.slice.

  7. Após editar o arquivo, certifique-se de que systemd recarregue seus arquivos de configuração e, em seguida, reinicie o serviço:
    sudo systemctl daemon-reload
    sudo systemctl restart myservice1
  8. Execute o comando systemd-cgls e confirme se o serviço myservice1 está sendo executado no segmento personalizado my_custom_slice:
    systemd-cgls
    Control group /:
    -.slice
    ...
    ├─user.slice (#1429)
    ...
    ├─my_custom_slice.slice (#7973)
    │ → user.invocation_id: a8a493a8db1342be85e2cdf1e80255f8
    │ └─myservice1.service (#8007)
    │   → user.invocation_id: 9a4a6171f2844e479d4a0f347aac38ce
    │   ├─22385 /bin/bash /usr/lib/systemd/generate_load.sh
    │   ├─22386 /bin/bash /usr/lib/systemd/generate_load.sh
    │   ├─22387 /bin/bash /usr/lib/systemd/generate_load.sh
    │   └─22388 /bin/bash /usr/lib/systemd/generate_load.sh
    ├─init.scope (#19)
    │ └─1 /usr/lib/systemd/systemd --switched-root --system --deserialize 28
    └─system.slice (#53)
      ├─irqbalance.service (#2907)
      │ → user.invocation_id: 00d64c9b9d224f179496a83536dd60bb
      │ └─1464 /usr/sbin/irqbalance --foreground
     ...
    

Usando Arquivos Drop-in

Para usar um arquivo drop-in para configurar recursos, execute as seguintes etapas:

  1. Crie o diretório para o arquivo drop-in de serviço.
    Dica

    O diretório "drop-in" para arquivos drop-in de um serviço está em /etc/systemd/system/service_name.service.d, em que service_name é o nome do serviço.

    Continuando com nosso exemplo com o serviço myservice1, executaríamos o seguinte comando:

    sudo mkdir -p /etc/systemd/system/myservice1.service.d/
  2. Crie 2 arquivos drop-in chamados 00-slice.conf e 10-CPUSettings.conf no diretório myservice1.service.d criado na etapa anterior.
    Observação

    • Vários arquivos drop-in com nomes diferentes são aplicados na ordem lexicográfica.

    • Esses arquivos drop-in têm precedência sobre o arquivo de unidade de serviço.

  3. Adicione o seguinte conteúdo a 00-slice.conf
    [Service]
    Slice=my_custom_slice2.slice
    MemoryAccounting=yes
    CPUAccounting=yes
    

    A definição de segmento Slice=my_custom_slice2.slice no arquivo drop-in tem precedência sobre a entrada Slice=my_custom_slice.slice adicionada ao arquivo de unidade de serviço em uma etapa anterior.

  4. E adicione o seguinte conteúdo a 10-CPUSettings.conf
    [Service]
    CPUWeight=200
    
  5. Crie um segundo serviço (myservice2) e atribua a ele um CPUWeight diferente ao designado a myservice1:
    1. Crie o arquivo /etc/systemd/system/myservice2.service com o seguinte conteúdo:
      [Service]
      Slice=my_custom_slice2.slice
      Type=oneshot
      ExecStart=/usr/lib/systemd/generate_load2.sh
      TimeoutSec=0
      StandardOutput=tty
      RemainAfterExit=yes
      
      [Install]
      WantedBy=multi-user.target
    2. O serviço criado na etapa anterior requer um script bash /usr/lib/systemd/generate_load2.sh. Crie o arquivo com o seguinte conteúdo: de
      #!/bin/bash
      for i in {1..4};do while : ; do : ; done & done
    3. Torne o script executável:
      sudo chmod +x /usr/lib/systemd/generate_load2.sh
    4. Crie uma eliminação no arquivo /etc/systemd/system/myservice2.service.d/10-CPUSettings.conf para myservice2 com o seguinte conteúdo:
      [Service]
      CPUWeight=400
      
  6. Certifique-se de que systemd recarregue seus arquivos de configuração e reinicie myservice1, além de ativar e iniciar myservices2:
    sudo systemctl daemon-reload
    sudo systemctl restart myservice1
    sudo systemctl enable myservice2 --now
  7. Execute o comando systemd-cgtop para exibir grupos de controle ordenados por seu uso de recursos. Na saída de amostra a seguir, você pode ver como, além do uso do recurso de cada segmento, o comando systemd-cgtop exibe o uso do recurso dentro de cada segmento, para que você possa usá-lo para confirmar se o peso da CPU foi dividido conforme esperado.
    systemd-cgtop
    Control Group                                     Tasks   %CPU   Memory  Input/s Output/s
    /                                                   228  198.8   712.5M        -        -
    my_custom_slice2.slice                                8  198.5     1.8M        -        -
    my_custom_slice2.slice/myservice2.service             4  132.8   944.0K        -        -
    my_custom_slice2.slice/myservice1.service             4   65.6   976.0K        -        -
    user.slice                                           18    0.9    43.9M        -        -
    user.slice/user-1001.slice                            6    0.9    13.7M        -        -
    user.slice/user-1001.slice/session-2.scope            4    0.9     9.4M        -        -
    system.slice                                         60    0.0   690.8M        -        -
    

Usando systemctl set-property

O comando systemctl set-property coloca os arquivos de configuração no seguinte local:

/etc/systemd/system.control
Cuidado

Você não deve editar manualmente o comando files systemctl set-property cria.

Observação

O comando systemctl set-property não reconhece todas as propriedades de controle de recursos usadas nos arquivos de unidade do sistema e drop-in abordados anteriormente neste tópico.

O seguinte procedimento mostra como você pode usar o comando systemctl set-property para configurar a alocação de recursos:

  1. Continuando com nosso exemplo, crie outro arquivo de serviço no local /etc/systemd/system/myservice3.service com o seguinte conteúdo:
    [Service]
    Type=oneshot
    ExecStart=/usr/lib/systemd/generate_load3.sh
    TimeoutSec=0
    StandardOutput=tty
    RemainAfterExit=yes
    [Install]
    WantedBy=multi-user.target
  2. Defina o segmento para o serviço como my_custom_slice2 (o mesmo segmento usado pelos serviços criados em etapas anteriores) adicionando a seguinte linha à seção [Service] no arquivo myservice3.service:
    Slice=my_custom_slice2.slice
    Observação

    O segmento deve ser definido no arquivo de unidade de serviço porque o comando systemctl set-property não reconhece a propriedade Slice.

  3. O serviço criado na etapa anterior requer um script bash /usr/lib/systemd/generate_load3.sh. Crie o arquivo com o seguinte conteúdo: de
    #!/bin/bash
    for i in {1..4};do while : ; do : ; done & done
  4. Torne o script executável:
    sudo chmod +x /usr/lib/systemd/generate_load3.sh
  5. Certifique-se de que systemd recarregue seus arquivos de configuração e, em seguida, ative e inicie o serviço:
    sudo systemctl daemon-reload
    sudo systemctl enable myservice3 --now
  6. Execute systemd-cgtop para confirmar que todos os 3 serviços, myservice1, myservice2 e myservice3, estão em execução no mesmo segmento.
  7. Use o comando systemctl set-property para definir o CPUWeight para myservice3 como 800:
    sudo systemctl set-property myservice3.service CPUWeight=800
  8. Confirme se um arquivo drop-in foi criado para você em /etc/systemd/system.control/myservice3.service.d. No entanto, não é necessário editar o arquivo:
    cat /etc/systemd/system.control/myservice3.service.d/50-CPUWeight.conf
    # This is a drop-in unit file extension, created via "systemctl set-property"
    # or an equivalent operation. Do not edit.
    [Service]
    CPUWeight=800
    
  9. Certifique-se de que systemd recarregue seus arquivos de configuração e reinicie todos os serviços:
    sudo systemctl daemon-reload
    sudo systemctl restart myservice1
    sudo systemctl restart myservice2
    sudo systemctl restart myservice3
  10. Execute o comando systemd-cgtop para confirmar se o peso da CPU foi dividido conforme esperado:
    systemd-cgtop
    Control Group                                         Tasks   %CPU   Memory  Input/s Output/s
    /                                                       235  200.0   706.1M        -        -
    my_custom_slice2.slice                                   12  198.4     2.9M        -        -
    my_custom_slice2.slice/myservice3.service                 4  112.7   976.0K        -        -
    my_custom_slice2.slice/myservice2.service                 4   56.9   996.0K        -        -
    my_custom_slice2.slice/myservice1.service                 4   28.8   988.0K        -        -
    user.slice                                               18    0.9    44.1M        -        -
    user.slice/user-1001.slice                                6    0.9    13.9M        -        -
    user.slice/user-1001.slice/session-2.scope                4    0.9     9.5M        -        -