The structured bindings proposal contains a dedicated section answering your question (P0144R2):

3.8 Should there be a way to explicitly ignore components?

The motivation would be to silence compiler warnings about unused names.
We think the answer should be “not yet.” This is not motivated by use cases (silencing compiler warnings is a motivation, but it is not a use case per se), and is best left until we can revisit this in the context of a more general pattern matching proposal where this should fall out as a special case.

Symmetry with std::tie would suggest using something like a std::ignore:

tuple<T1,T2,T3> f();

auto [x, std::ignore, z] = f(); // NOT proposed: ignore second element

However, this feels awkward.

Anticipating pattern matching in the language could suggest a wildcard like _ or *, but since we do not yet have pattern matching it is premature to pick a syntax that we know will be compatible. This is a pure extension that can wait to be considered with pattern matching.

However, note that the working draft of the Standard is currently being revised by the relevant National Bodies (NB), and there is a NB comment requesting this feature (P0488R0, US100):

Decomposition declarations should provide syntax to discard some of the returned values, just as std::tie uses std::ignore.

C++26 will introduce A nice placeholder with no name (P2169R0). With this new language feature, one finally can use _ as a way to ignore variables in a structured-binding expression. For details on the design, see the linked document.

Will it be possible to do something similar using the new structured bindings syntax?

No. You’ll just have to make up a variable name that won’t be mentioned later.

I usually use _ which is a valid identifier in C++ but looks the same as for example Kotlin’s underscore operator which discards lambda parameters.
You’d end up with a nice code sth like this

map([&](auto it) {
    auto [_, deviceServiceXAddr] = it;
    return deviceServiceXAddr;
});

Here’s a quick and dirty hack, but it will work only for one underscore per line.
(Using C++20’s source_location could extend it to columns as well…):

#define __CONCAT(x,y) x ## y
#define _CONCAT(x,y) __CONCAT(x,y)
#define _ _CONCAT(__tmp_ignore_var_, __LINE__)

int main(int argc, char* argv[])
{
    auto p = make_pair(2,"hello");
    auto [_, b] = p;
    auto [a, _] = p;
    return 0;
}