You are browsing a read-only backup copy of Wikitech. The live site can be found at wikitech.wikimedia.org

Help:Toolforge/Pywikibot: Difference between revisions

From Wikitech-static
Jump to navigation Jump to search
imported>Rubin
imported>BryanDavis
(Add communication template)
 
(7 intermediate revisions by 5 users not shown)
Line 1: Line 1:
{{Pywikibot outdated}}
{{Note|This page is related to https://wikitech.wikimedia.org/wiki/Help:Toolforge/My_first_Pywikibot_tool. These pages will be combined for simpler documentation.}}
{{Toolforge nav}}
{{Toolforge nav}}


The '''[[mw:Manual:Pywikibot|Pywikibot Framework]]''' is a collection of Python tools that automate work on MediaWiki sites. Please review [[mw:Manual:Pywikibot/Installation]] first.
The '''[[:mw:Special:MyLanguage/Manual:Pywikibot|Pywikibot]]''' framework is a Python library and collection of scripts to automate work on MediaWiki sites.


The stable version of the Pywikibot 'core' branch (formerly 'rewrite') is accessible at <code>/shared/pywikibot/stable</code>. If you are a developer and/or would like to use the current master branch, this is accessible at <code>/shared/pywikibot/core</code> but be aware this might not be a stable release. To have control when the code is updated, you may also choose to [[#Setup pywikibot on Toolforge (locally)|install 'core' locally]] in your tool directory.
== Installation and setup ==
{{See also|mw:Special:MyLanguage/Manual:Pywikibot/Installation}}
# Become your tool-account<syntaxhighlight lang="shell-session">MAINTAINER@tools-sgebastion-10:~$ become TOOLNAME</syntaxhighlight>
# Create a setup script (e.g., <code>pwb_venv.sh</code>) that creates a [https://docs.python.org/3/tutorial/venv.html virtual environment] and installs dependencies. <syntaxhighlight lang="shell-session">tools.TOOLNAME@tools-sgebastion-10:~$ touch $HOME/pwb_venv.sh
tools.TOOLNAME@tools-sgebastion-10:~$ chmod ug+x $HOME/pwb_venv.sh  # make the script executable</syntaxhighlight> You need to install from git if you want to use the [https://doc.wikimedia.org/pywikibot/stable/scripts/index.html Pywikibot scripts].


Note that the shared 'core' code consists only of the source files; each bot operator will need to create their own configuration files (such as 'user-config.py') and set up a PYTHONPATH and other environment variables. Please see [[#Using the shared Pywikibot files (recommended setup)|Using the shared Pywikibot files]] for more information.
{| class="wikitable"
 
! Pywikibot installation source
== Using the shared Pywikibot files (recommended setup) ==
! Example
For most purposes, using the centralized 'core' files is recommended. The shared files are available at <code>/data/project/shared/pywikibot/stable</code>, and steps for configuring your tool account are provided below. The configuration files themselves are stored in your tool account in the <code>$HOME/.pywikibot</code> directory, or another directory, where they can be used via the <code>-dir</code> option (all of this is described in more detail in the instructions).
|-
 
! scope="row" | PyPI
If you are a developer and/or would like to control when the code is updated, please see [[#Setup pywikibot on Toolforge (locally) | Installing Pywikibot locally]] for instructions.
| {{Codesample|name=pwb_venv.sh|lang=bash|scheme=light|code=
 
#!/bin/bash
'''To set up your Tools account to use the shared 'core' framework:'''
 
1. Become your tool-account
<syntaxhighlight lang="shell-session">
maintainer@tools-login:~$ become toolname
</syntaxhighlight>
 
2. In your home directory, create (or edit, if it exists already) a '.bash_profile' file:
 
<syntaxhighlight lang="sh">
nano .bash_profile
</syntaxhighlight>
 
and include the following line:
 
<syntaxhighlight lang="sh">
export PYTHONPATH=/data/project/shared/pywikibot/stable:/data/project/shared/pywikibot/stable/scripts
</syntaxhighlight>
 
The path should be on one line, though it may appear to be on multiple lines depending on your screen width. When you save the .bash_profile file ({{key press|CTRL|X}}), your settings will be updated for all future shell sessions.
 
3. Import the path settings into your current session:
<syntaxhighlight lang="shell-session">
tools.tool@tools-login$ source .bash_profile
</syntaxhighlight>
 
4. In your home directory, create a subdirectory named '.pywikibot' (the '.' is important!) for bot-related files:
<syntaxhighlight lang="shell-session">
tools.tool@tools-login$ mkdir $HOME/.pywikibot
</syntaxhighlight>
[[File:Python_-data-project-shared-pywikibot-core-generate_user_files-py.png|thumb|example of configuration for commons.wikimedia.org]]
 
5. Configure Pywikibot.
 
To create configuration files, use the following command and then follow the instructions. You may also use an existing configuration file (e.g., 'user-config.py') that works on another system by copying it into your .pywikibot directory:
<syntaxhighlight lang="shell-session">
tools.tool@tools-login$ python3 /data/project/shared/pywikibot/stable/pywikibot/scripts/generate_user_files.py
</syntaxhighlight>
 
6. Test out your setup.
In general, all jobs should be [[#Submitting, managing and scheduling jobs on the grid|run on the grid]], but it's fine to test your setup on the command line. You should see the following terminal output (or something similar):
<syntaxhighlight lang="shell-session">
tools.tool@tools-login$ python3 /data/project/shared/pywikibot/stable/pywikibot/scripts/version.py
Pywikibot: [https] r-pywikibot-core.git (1db1f28, g15095, 2021/05/31, 14:35:28, stable)
Release version: 6.3.0
requests version: 2.12.4
  cacerts: /etc/ssl/certs/ca-certificates.crt
    certificate test: ok
Python: 3.5.3 (default, Sep 27 2018, 17:25:39)
[GCC 6.3.0 20170516]
</syntaxhighlight>
 
Note that you do not need to run scripts using pwb.py, but run scripts directly, e.g., <code>python3 /data/project/shared/pywikibot/stable/pywikibot/scripts/version.py</code>. Setting <tt>PYTHONPATH</tt> means that you no longer need the pwb.py helper script to make, say, <code>import pywikibot</code> work. Anyway the pwb.py helper script has additional advantages like ignoring typing mistakes for script names, script path redirection, dependency checks, see [https://doc.wikimedia.org/pywikibot/master/utilities/index.html?#module-pwb pwb script documentation].
 
If you need to use multiple user-config.py files, you can do so by adding <tt>-dir:<path where you want your user-config.py></tt> to every python command. To use the local directory, use <tt>-dir:.</tt> (colon dot).
 
For more information about Pywikibot, please see the [[mw:Manual:Pywikibot|Pywikibot documentation]]. The pywikibot mailing list (pywikibot{{@}}lists.wikimedia.org) and IRC channel ({{irc|pywikibot}}) are good places to go for additional help. Other useful information about using the centralized 'core' files is available here: [[User:Russell Blau/Using pywikibot on Labs]]
 
{{caution}} Script path for Pywikibot framework utility scripts (<tt>generate_family_file.py</tt>, <tt>generate_user_files.py</tt>, <tt>shell.py</tt>, <tt>version.py</tt>) has been changed in core (master) branch with release 7.0.0. To use them the path is <code>/data/project/shared/pywikibot/core/pywikibot/scripts/<script_name></code> or it can be invoked by the <tt>pwb.py</tt> wrapper script. See also: https://doc.wikimedia.org/pywikibot/master/utilities/index.html
 
== Setup pywikibot on Toolforge (locally) ==
{{anchor|Setup pywikibot on Labs (locally)}}
Installing pywikibot local to your tool allows you to upgrade whenever it suits you, instead of always running the latest version.
 
=== {{Anchor|Installing core}} Clone pywikibot git repo ===
Clone the 'core' git repository:
<syntaxhighlight lang="shell-session">
$ git clone --recursive --branch stable "https://gerrit.wikimedia.org/r/pywikibot/core" $HOME/pywikibot-core
</syntaxhighlight>
 
=== Setup a Python virtual environment for library dependencies ===
{{Anchor|virtualenv}}{{Anchor|install as module - virtualenv}}
When using a local pywikibot install, use a [https://docs.python.org/3/tutorial/venv.html Python virtual environment] (venv) to manage Python library dependencies. The Toolforge environment does provide system packages for many Python libraries, but these are installed using Debian packages which means that they are often older versions and not likely to be upgraded often.
 
Create a venv. You can give this venv any name you would like. We will use 'pwb' in this example.
<syntaxhighlight lang="shell-session">
$ python3 -m venv $HOME/pwb
</syntaxhighlight>
 
Once you have created the venv, you can "activate" it to setup your shell's $PATH so that the <code>python3</code> and <code>pip3</code> binaries in the virtual environment are used by default.
<syntaxhighlight lang="shell-session">
$ source $HOME/pwb/bin/activate
(pwb) $
</syntaxhighlight>
 
Now that the venv is created and active for your current shell session, we can install the pywikibot code from the git clone we made earlier into this venv. This basically installs the pywikibot core code as a symlink in the venv. This way, if you modify the directory, you don't need to install it again.
<syntaxhighlight lang="shell-session">
(pwb) $ pip3 install --upgrade pip "setuptools>=49.4.0, !=50.0.0, <50.2.0" wheel
...
Successfully installed pip-21.2.4 setuptools-58.1.0 wheel-0.37.0
(pwb) $ cd $HOME/pywikibot-core
(pwb) $ pip3 install -e .[mwparserfromhell,mwoauth,mysql]  # adjust extra dependencies as needed for your tool
...
Finished processing dependencies for pywikibot==6.6.1
</syntaxhighlight>
 
Note: the <code>setuptools!=50.0.0</code> install constraint is for [[phab:T261748|T261748]] and the [https://github.com/pypa/setuptools/issues/2352 upstream issue in setuptools] related to relative imports.
 
=== Using the virtual environment without activating it ===
To use the code from outside the virtual environment (for example to submit jobs to the grid engine), use the full paths to the <code>python3</code> inside your venv directory and the full path to the script you want to run:
<syntaxhighlight lang="shell-session">
$ $HOME/pwb/bin/python3 $HOME/path/to/script.py
</syntaxhighlight>
 
=== Using the virtual environment on Kubernetes ===
The way to launch and customise the virtual environment is different on [[News/Toolforge Stretch deprecation|Kubernetes]].


The virtual environment should be defined in the toolforge-job itself. Create a script similar to this:
# clean-up directories if they already exist
 
rm -fdr pwbvenv
{{Codesample|name=pwb_venv.sh|lang=bash|scheme=light|code=
#!/bin/bash


# create the venv
# create a virtual environment
python3 -m venv pwbvenv
python3 -m venv pwbvenv


Line 133: Line 26:
source pwbvenv/bin/activate
source pwbvenv/bin/activate


# install some packages
# install dependencies
pip3 install --upgrade pip "setuptools>=49.4.0, !=50.0.0, <50.2.0" wheel
pip install --upgrade pip setuptools wheel
cd $HOME/pywikibot-core
pip install pywikibot[mwparserfromhell,mwoauth,mysql] # update as needed
pip3 install -e .[mwparserfromhell,mwoauth,mysql]  
pip install ... # any other dependencies here
}}
}}
 
|-
<syntaxhighlight lang="shell-session">
! scope="row" | git
tools.mytool@tools-sgebastion-11:~$ chmod ug+x pwb_venv.sh
| {{Codesample|name=pwb_venv.sh|lang=bash|scheme=light|code=
tools.mytool@tools-sgebastion-11:~$ toolforge-jobs run pwb-venv --command "./pwb_venv.sh" --image tf-python39 --wait
INFO: job 'pwb-venv' completed
</syntaxhighlight>
 
== Setup job submission ==
After installing, you can run your bot directly via a shell command, though this is highly discouraged. You should use the grid to run jobs instead.
 
In order to setup the submission of the jobs you want to execute and use the grid engine you should first read [[Help:Toolforge/Grid]].
 
To run a bot using the grid, you might want to be in the pywikibot directory (this is not needed) - which means you have to write a small wrapper script. The following example script (versiontest.sh) is used to run version.py:
 
<syntaxhighlight lang="shell-session">
$ cat versiontest.sh
#!/bin/bash
#!/bin/bash
cd /data/project/shared/pywikibot/stable
python3 version.py
</syntaxhighlight>


To submit a job, set the permissions for the script and then use the 'jsub' command to send the job to the grid:
# clean-up directories if they already exist
<syntaxhighlight lang="shell-session">
rm -fdr pwbvenv $HOME/pywikibot-core
$ chmod 0755 versiontest.sh
$ jsub versiontest.sh
</syntaxhighlight>


Job output will be written to output and error files in your home directory called YOURJOBNAME.out and YOURJOBNAME.err, respectively (versiontest.out and versiontest.err in this example):
# create a virtual environment
<syntaxhighlight lang="shell-session">
python3 -m venv pwbvenv
$ cat ~/versiontest.out
pywikibot [https] r/pywikibot/compat (r10211, 8fe6bdc, 2013/08/18, 14:00:57, ok)
Python 2.7.3 (default, Aug  1 2012, 05:14:39)
[GCC 4.6.3]
config-settings:
use_api = True
use_api_login = True
unicode test: ok
</syntaxhighlight>


=== Example ===
# activate it
An [[Help:Toolforge/Grid#Submitting continuous jobs (such as bots) with 'jstart'|infinitely running job]] such as an irc-bot can be started like this:
source pwbvenv/bin/activate
 
<syntaxhighlight lang="shell-session">
$ jsub -once -continuous -l h_vmem=256M -N script_wui python3 $HOME/pywikibot-core/pwb.py script_wui.py -log
</syntaxhighlight>
or shorter
<syntaxhighlight lang="shell-session">
$ jstart -l h_vmem=256M -N script_wui python3 $HOME/pywikibot-core/pwb.py script_wui.py -log
</syntaxhighlight>


If you experience problems with your jobs, like e.g.
# clone Pywikibot
Fatal Python error: Couldn't create autoTLSkey mapping
git clone --recursive --branch stable "https://gerrit.wikimedia.org/r/pywikibot/core" $HOME/pywikibot-core
you can try increasing the memory value:
<syntaxhighlight lang="shell-session">
$ jstart -l h_vmem=512M -N script_wui python3 $HOME/pywikibot-core/pwb.py script_wui.py -log
</syntaxhighlight>


Now in order to create a crontab follow [[Help:Toolforge/Grid#Scheduling jobs at regular intervals with cron|scheduling jobs at regular intervals with cron]] and setup for crontab file like:
# install dependencies
<syntaxhighlight lang="shell-session">
pip install --upgrade pip setuptools wheel
$ crontab -e
pip install $HOME/pywikibot-core[mwparserfromhell,mwoauth,mysql]  # update as needed
</syntaxhighlight>
pip install ... # any other dependencies here
and enter
}}
<syntaxhighlight lang="text">
|}
PATH=/usr/local/bin:/usr/bin:/bin
#<li value="3"> Run the setup script using the [[Help:Toolforge/Jobs framework|jobs framework]]. <syntaxhighlight lang="shell-session">tools.TOOLNAME@tools-sgebastion-10:~$ toolforge-jobs run setup-venv --command $HOME/pwb_venv.sh --image tf-python39 --wait
 
INFO: job 'setup-venv' completed</syntaxhighlight>
# Run script_wui.py at 00:17 UTC each day
# Configure Pywikibot
17 0 * * * jstart -l h_vmem=512M -N script_wui python3 $HOME/pywikibot-core/pwb.py script_wui.py -log
#* Interactively:<syntaxhighlight lang="shell-session">
</syntaxhighlight>
tools.TOOLNAME@tools-sgebastion-10:~$ webservice python3.9 shell  # start an interactive Kubernetes shell
 
tools.TOOLNAME@shell-#########:~$ source pwbvenv/bin/activate  # activate the virtual environment
=== Kubernetes ===
(pwbvenv) tools.TOOLNAME@shell-#########:~$ pwb generate_user_files  # run the generate_user_files.py Pywikibot script
The system of job creation on Kubernetes is different. First, the virtual environment [[Help:Toolforge/Pywikibot#Using_the_virtual_environment_on_Kubernetes|needs to be customised]].
</syntaxhighlight> [[:mw:Special:MyLanguage/Manual:Pywikibot/user-config.py|user-config.py]] and (optionally) user-password.py are generated by following the prompts.
 
#* Manually: See the manual on MediawWiki wiki: [[:mw:Special:MyLanguage/Manual:Pywikibot/user-config.py|user-config.py]], [[:mw:Special:MyLanguage/Manual:Pywikibot/BotPasswords|BotPasswords]], and [[:mw:Special:MyLanguage/Manual:Pywikibot/OAuth|OAuth]].
After that, the job could be launched:
# Before exiting the shell, you may test the installation. <syntaxhighlight lang="shell-session">
<syntaxhighlight lang="shell-session">
(pwbvenv) tools.TOOLNAME@shell-#########:~$ pwb version  # run the version.py Pywikibot script
$ toolforge-jobs run script_name --command "$HOME/pwbvenv/bin/python3 $HOME/pywikibot-core/pwb.py script_name -start:!" --image tf-python39
Pywikibot: pywikibot/__init__.py (, -1 (unknown), 2022/11/03, 21:47:06, UNKNOWN)
</syntaxhighlight>
Release version: 7.7.1
 
setuptools version: 65.5.0
Additional parameters for the job could be reviewed on [[Help:Toolforge/Jobs framework]] and could include, for example, additional memory allocation (<code>--mem MEM</code>), job restart after being finished (<code>--continuous</code>), etc.
mwparserfromhell version: 0.6.4
 
wikitextparser version: n/a
== Using pip ==
requests version: 2.28.1
The [[:en:Pip (package manager)|pip]] package manager is not installed for global use on the Toolforge servers, but it can be used through the use of virtual environments. The first step is to create a virtual environment, and get the latest version of <code>pip</code> installed in it:
  cacerts: /data/project/TOOLNAME/pwbvenv/lib/python3.9/site-packages/certifi/cacert.pem
 
    certificate test: ok
<syntaxhighlight lang="shell-session">
Python: 3.9.2 (default, Feb 28 2021, 17:03:44)
$ python3 -m venv venv
[GCC 10.2.1 20210110]
$ source venv/bin/activate
PYWIKIBOT_DIR: Not set
$ pip3 install --upgrade pip
PYWIKIBOT_DIR_PWB: /data/project/TOOLNAME/pwbvenv/lib/python3.9/site-packages/pywikibot/scripts
PYWIKIBOT_NO_USER_CONFIG: Not set
Config base dir: /data/project/TOOLNAME
Usernames for family 'commons':
        commons: Example bot
</syntaxhighlight>
</syntaxhighlight>


Installing specific packages from <code>pip3</code> is as simple as loading the environment and then running the <code>pip3 install</code> command, for example:
== Create jobs ==
 
{{Main|Help:Toolforge/Jobs framework}}
Example of running the [[:mw:Special:MyLanguage/Manual:Pywikibot/version.py|Pywikibot version.py]] script once:
<syntaxhighlight lang="shell-session">
<syntaxhighlight lang="shell-session">
$ source venv/bin/activate
tools.TOOLNAME@tools-sgebastion-10:~$ toolforge-jobs run pywikibot-version --command "$HOME/pwbvenv/bin/pwb version" --image tf-python39
$ pip3 install PACKAGENAME
</syntaxhighlight>
</syntaxhighlight>


Lastly, running a pywikibot script that depends on a <code>pip</code> package will also require loading the environment first, for instance:
Example of running your own script on a schedule:
 
<syntaxhighlight lang="shell-session">
<syntaxhighlight lang="shell-session">
$ source venv/bin/activate
tools.TOOLNAME@tools-sgebastion-10:~$ toolforge-jobs run my-cool-job --command "$HOME/pwbvenv/bin/python3 $HOME/my-cool-script.py" --image tf-python39 --schedule "1 2 * * 3"
$ python3 foo/bar/pwb.py SCRIPTNAME -page:"SOMEPAGE"
</syntaxhighlight>
</syntaxhighlight>


The venv does not get automatically activated in Grid job submissions. Two common workarounds are having wrapping shell scripts that activates the venv, or use absolute paths to the binaries within:
Additional parameters for the job could include, for example, additional memory allocation (<code>--mem MEM</code>), job restart after being finished (<code>--continuous</code>), etc.
 
<syntaxhighlight lang="shell-session">
$ jstart -N jobname venv/bin/python3 foo/bar/pwb.py SCRIPTNAME -page:"SOMEPAGE"
</syntaxhighlight>


{{:Help:Cloud Services communication}}
[[Category:Toolforge|Pywikibot]]
[[Category:Toolforge|Pywikibot]]

Latest revision as of 21:27, 4 November 2022

The Pywikibot framework is a Python library and collection of scripts to automate work on MediaWiki sites.

Installation and setup

  1. Become your tool-account
    MAINTAINER@tools-sgebastion-10:~$ become TOOLNAME
    
  2. Create a setup script (e.g., pwb_venv.sh) that creates a virtual environment and installs dependencies.
    tools.TOOLNAME@tools-sgebastion-10:~$ touch $HOME/pwb_venv.sh
    tools.TOOLNAME@tools-sgebastion-10:~$ chmod ug+x $HOME/pwb_venv.sh  # make the script executable
    
    You need to install from git if you want to use the Pywikibot scripts.
Pywikibot installation source Example
PyPI
pwb_venv.sh
#!/bin/bash

# clean-up directories if they already exist
rm -fdr pwbvenv

# create a virtual environment
python3 -m venv pwbvenv

# activate it
source pwbvenv/bin/activate

# install dependencies
pip install --upgrade pip setuptools wheel
pip install pywikibot[mwparserfromhell,mwoauth,mysql]  # update as needed
pip install ... # any other dependencies here
git
pwb_venv.sh
#!/bin/bash

# clean-up directories if they already exist
rm -fdr pwbvenv $HOME/pywikibot-core

# create a virtual environment
python3 -m venv pwbvenv

# activate it
source pwbvenv/bin/activate

# clone Pywikibot
git clone --recursive --branch stable "https://gerrit.wikimedia.org/r/pywikibot/core" $HOME/pywikibot-core

# install dependencies
pip install --upgrade pip setuptools wheel
pip install $HOME/pywikibot-core[mwparserfromhell,mwoauth,mysql]  # update as needed
pip install ... # any other dependencies here
  1. Run the setup script using the jobs framework.
    tools.TOOLNAME@tools-sgebastion-10:~$ toolforge-jobs run setup-venv --command $HOME/pwb_venv.sh --image tf-python39 --wait
    INFO: job 'setup-venv' completed
    
  2. Configure Pywikibot
    • Interactively:
      tools.TOOLNAME@tools-sgebastion-10:~$ webservice python3.9 shell  # start an interactive Kubernetes shell
      tools.TOOLNAME@shell-#########:~$ source pwbvenv/bin/activate  # activate the virtual environment
      (pwbvenv) tools.TOOLNAME@shell-#########:~$ pwb generate_user_files  # run the generate_user_files.py Pywikibot script
      
      user-config.py and (optionally) user-password.py are generated by following the prompts.
    • Manually: See the manual on MediawWiki wiki: user-config.py, BotPasswords, and OAuth.
  3. Before exiting the shell, you may test the installation.
    (pwbvenv) tools.TOOLNAME@shell-#########:~$ pwb version  # run the version.py Pywikibot script
    Pywikibot: pywikibot/__init__.py (, -1 (unknown), 2022/11/03, 21:47:06, UNKNOWN)
    Release version: 7.7.1
    setuptools version: 65.5.0
    mwparserfromhell version: 0.6.4
    wikitextparser version: n/a
    requests version: 2.28.1
      cacerts: /data/project/TOOLNAME/pwbvenv/lib/python3.9/site-packages/certifi/cacert.pem
        certificate test: ok
    Python: 3.9.2 (default, Feb 28 2021, 17:03:44)
    [GCC 10.2.1 20210110]
    PYWIKIBOT_DIR: Not set
    PYWIKIBOT_DIR_PWB: /data/project/TOOLNAME/pwbvenv/lib/python3.9/site-packages/pywikibot/scripts
    PYWIKIBOT_NO_USER_CONFIG: Not set
    Config base dir: /data/project/TOOLNAME
    Usernames for family 'commons':
            commons: Example bot
    

Create jobs

Main article: Help:Toolforge/Jobs framework

Example of running the Pywikibot version.py script once:

tools.TOOLNAME@tools-sgebastion-10:~$ toolforge-jobs run pywikibot-version --command "$HOME/pwbvenv/bin/pwb version" --image tf-python39

Example of running your own script on a schedule:

tools.TOOLNAME@tools-sgebastion-10:~$ toolforge-jobs run my-cool-job --command "$HOME/pwbvenv/bin/python3 $HOME/my-cool-script.py" --image tf-python39 --schedule "1 2 * * 3"

Additional parameters for the job could include, for example, additional memory allocation (--mem MEM), job restart after being finished (--continuous), etc.

Communication and support

Support and administration of the WMCS resources is provided by the Wikimedia Foundation Cloud Services team and Wikimedia movement volunteers. Please reach out with questions and join the conversation:

Discuss and receive general support
Receive mail announcements about critical changes
Subscribe to the cloud-announce@ mailing list (all messages are also mirrored to the cloud@ list)
Track work tasks and report bugs
Use the Phabricator workboard #Cloud-Services for bug reports and feature requests about the Cloud VPS infrastructure itself
Learn about major near-term plans
Read the News wiki page
Read news and stories about Wikimedia Cloud Services
Read the Cloud Services Blog (for the broader Wikimedia movement, see the Wikimedia Technical Blog)